diff --git a/Jenkinsfile b/Jenkinsfile index edb4c78..c84279b 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -17,7 +17,7 @@ node { sh "mvn -B clean install" stage 'Deploy' - sh "mvn -s ${env.HOME}/usethesource-maven-settings.xml -B deploy" + sh "mvn -s ${env.HOME}/usethesource-maven-settings.xml -B deploy -DskipTests" stage 'Archive' step([$class: 'ArtifactArchiver', artifacts: '**/target/*.jar', fingerprint: true]) diff --git a/capsule-core/capsule-core.iml b/capsule-core/capsule-core.iml new file mode 100644 index 0000000..e2b85dc --- /dev/null +++ b/capsule-core/capsule-core.iml @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/capsule-core/pom.xml b/capsule-core/pom.xml new file mode 100644 index 0000000..81af585 --- /dev/null +++ b/capsule-core/pom.xml @@ -0,0 +1,21 @@ + + 4.0.0 + + + io.usethesource + capsule-pom-parent + 0.3.0.HETEROGENEOUS-SNAPSHOT + + + io.usethesource + capsule + 0.3.0.HETEROGENEOUS-SNAPSHOT + jar + + + ${project.parent.basedir} + + + \ No newline at end of file diff --git a/capsule-core/src/main/java/io/usethesource/capsule/BinaryRelation.java b/capsule-core/src/main/java/io/usethesource/capsule/BinaryRelation.java new file mode 100644 index 0000000..e65b952 --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/BinaryRelation.java @@ -0,0 +1,33 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +public interface BinaryRelation extends SetMultimap { + + BinaryRelation inverse(); + + SetMultimap toSetMultimap(); + + interface Immutable extends BinaryRelation, SetMultimap.Immutable { + + @Override + boolean isTransientSupported(); + + @Override + BinaryRelation.Transient asTransient(); + + } + + interface Transient extends BinaryRelation, SetMultimap.Transient { + + @Override + BinaryRelation.Immutable freeze(); + + } + +} diff --git a/capsule-core/src/main/java/io/usethesource/capsule/Map.java b/capsule-core/src/main/java/io/usethesource/capsule/Map.java new file mode 100644 index 0000000..69e3db3 --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/Map.java @@ -0,0 +1,167 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.util.Iterator; + +import io.usethesource.capsule.core.PersistentTrieMap; + +public interface Map extends java.util.Map, MapEq { + + @Override + int size(); + + @Override + boolean isEmpty(); + + @Override + boolean containsKey(final Object o); + + @Override + boolean containsValue(final Object o); + + @Override + V get(final Object o); + + Iterator keyIterator(); + + Iterator valueIterator(); + + Iterator> entryIterator(); + + interface Immutable extends Map, MapEq.Immutable { + + Map.Immutable __put(final K key, final V val); + + Map.Immutable __remove(final K key); + + Map.Immutable __putAll(final java.util.Map map); + + boolean isTransientSupported(); + + Map.Transient asTransient(); + + static Map.Immutable of() { + return PersistentTrieMap.of(); + } + + static Map.Immutable of(K key, V value) { + return PersistentTrieMap.of(key, value); + } + + static Map.Immutable of(K key0, V value0, K key1, V value1) { + return PersistentTrieMap.of(key0, value0, key1, value1); + } + + } + + interface Transient extends Map, MapEq.Transient { + + V __put(final K key, final V val); + + V __remove(final K key); + + boolean __putAll(final java.util.Map map); + +// default boolean union(final Map map) { +// boolean modified = false; +// +// for (java.util.Map.Entry entry : map.entrySet()) { +// // NOTE: does only work when map does not support `null` values +// if (this.__put(entry.getKey(), entry.getValue()) != null) { +// modified |= true; +// } +// } +// +// return modified; +// } +// +// default boolean intersect(final Map map) { +// throw new UnsupportedOperationException("Not yet implemented @ Map."); +// } +// +// default boolean complement(final Map map) { +// throw new UnsupportedOperationException("Not yet implemented @ Map"); +// } + + Map.Immutable freeze(); + + static Map.Transient of() { + return PersistentTrieMap.transientOf(); + } + + static Map.Transient of(K key0, V value0) { + final Map.Transient tmp = Map.Transient.of(); + + tmp.__put(key0, value0); + + return tmp; + } + + static Map.Transient of(K key0, V value0, K key1, V value1) { + final Map.Transient tmp = Map.Transient.of(); + + tmp.__put(key0, value0); + tmp.__put(key1, value1); + + return tmp; + } + + static Map.Transient of(K key0, V value0, K key1, V value1, K key2, + V value2) { + final Map.Transient tmp = Map.Transient.of(); + + tmp.__put(key0, value0); + tmp.__put(key1, value1); + tmp.__put(key2, value2); + + return tmp; + } + + static Map.Transient of(K key0, V value0, K key1, V value1, K key2, + V value2, K key3, V value3) { + final Map.Transient tmp = Map.Transient.of(); + + tmp.__put(key0, value0); + tmp.__put(key1, value1); + tmp.__put(key2, value2); + tmp.__put(key3, value3); + + return tmp; + } + + static Map.Transient of(K key0, V value0, K key1, V value1, K key2, + V value2, K key3, V value3, K key4, V value4) { + final Map.Transient tmp = Map.Transient.of(); + + tmp.__put(key0, value0); + tmp.__put(key1, value1); + tmp.__put(key2, value2); + tmp.__put(key3, value3); + tmp.__put(key4, value4); + + return tmp; + } + + static Map.Transient of(K key0, V value0, K key1, V value1, K key2, + V value2, K key3, V value3, K key4, V value4, K key5, V value5) { + final Map.Transient tmp = Map.Transient.of(); + + tmp.__put(key0, value0); + tmp.__put(key1, value1); + tmp.__put(key2, value2); + tmp.__put(key3, value3); + tmp.__put(key4, value4); + tmp.__put(key5, value5); + + return tmp; + } + + } + +} diff --git a/capsule-core/src/main/java/io/usethesource/capsule/MapEq.java b/capsule-core/src/main/java/io/usethesource/capsule/MapEq.java new file mode 100644 index 0000000..c9974ce --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/MapEq.java @@ -0,0 +1,66 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.util.Comparator; + +/** + * Map extension providing methods that take a comparator. Closes over base (and not extended) map. + */ +@Deprecated +public interface MapEq extends java.util.Map { + + default boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Map."); + } + + default boolean containsValueEquivalent(final Object o, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Map."); + } + + default V getEquivalent(final Object o, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Map."); + } + + @Deprecated + interface Immutable extends MapEq { + + default Map.Immutable __putEquivalent(final K key, final V val, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Map."); + } + + default Map.Immutable __removeEquivalent(final K key, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Map."); + } + + default Map.Immutable __putAllEquivalent( + final java.util.Map map, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Map."); + } + + } + + @Deprecated + interface Transient extends MapEq { + + default V __putEquivalent(final K key, final V val, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Map."); + } + + default V __removeEquivalent(final K key, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Map."); + } + + default boolean __putAllEquivalent(final java.util.Map map, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Map."); + } + + } +} diff --git a/capsule-core/src/main/java/io/usethesource/capsule/Set.java b/capsule-core/src/main/java/io/usethesource/capsule/Set.java new file mode 100644 index 0000000..a350a73 --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/Set.java @@ -0,0 +1,146 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.util.Collection; +import java.util.Iterator; + +import io.usethesource.capsule.core.PersistentTrieSet; + +public interface Set extends java.util.Set, SetEq { + + @Override + int size(); + + @Override + boolean isEmpty(); + + @Override + boolean contains(Object o); + + @Override + boolean containsAll(Collection c); + + K get(Object o); + + Iterator keyIterator(); + + interface Immutable extends Set, SetEq.Immutable { + + Set.Immutable __insert(final K key); + + Set.Immutable __remove(final K key); + + Set.Immutable __insertAll(final java.util.Set set); + + Set.Immutable __removeAll(final java.util.Set set); + + Set.Immutable __retainAll(final java.util.Set set); + + boolean isTransientSupported(); + + Set.Transient asTransient(); + + static Set.Immutable of() { + return PersistentTrieSet.of(); + } + + static Set.Immutable of(K item) { + return PersistentTrieSet.of(item); + } + + static Set.Immutable of(K item0, K item1) { + return PersistentTrieSet.of(item0, item1); + } + + } + + interface Transient extends Set, SetEq.Transient { + + boolean __insert(final K key); + + boolean __remove(final K key); + + boolean __insertAll(final java.util.Set set); + + boolean __removeAll(final java.util.Set set); + + boolean __retainAll(final java.util.Set set); + + Set.Immutable freeze(); + + static Set.Transient of() { + return PersistentTrieSet.transientOf(); + } + + static Set.Transient of(K key0) { + final Set.Transient tmp = Set.Transient.of(); + + tmp.__insert(key0); + + return tmp; + } + + static Set.Transient of(K key0, K key1) { + final Set.Transient tmp = Set.Transient.of(); + + tmp.__insert(key0); + tmp.__insert(key1); + + return tmp; + } + + static Set.Transient of(K key0, K key1, K key2) { + final Set.Transient tmp = Set.Transient.of(); + + tmp.__insert(key0); + tmp.__insert(key1); + tmp.__insert(key2); + + return tmp; + } + + static Set.Transient of(K key0, K key1, K key2, K key3) { + final Set.Transient tmp = Set.Transient.of(); + + tmp.__insert(key0); + tmp.__insert(key1); + tmp.__insert(key2); + tmp.__insert(key3); + + return tmp; + } + + static Set.Transient of(K key0, K key1, K key2, K key3, K key4) { + final Set.Transient tmp = Set.Transient.of(); + + tmp.__insert(key0); + tmp.__insert(key1); + tmp.__insert(key2); + tmp.__insert(key3); + tmp.__insert(key4); + + return tmp; + } + + static Set.Transient of(K key0, K key1, K key2, K key3, K key4, K key5) { + final Set.Transient tmp = Set.Transient.of(); + + tmp.__insert(key0); + tmp.__insert(key1); + tmp.__insert(key2); + tmp.__insert(key3); + tmp.__insert(key4); + tmp.__insert(key5); + + return tmp; + } + + } + +} diff --git a/capsule-core/src/main/java/io/usethesource/capsule/SetEq.java b/capsule-core/src/main/java/io/usethesource/capsule/SetEq.java new file mode 100644 index 0000000..05a0e26 --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/SetEq.java @@ -0,0 +1,86 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.util.Collection; +import java.util.Comparator; + +/** + * Set extension providing methods that take a comparator. Closes over base (and not extended) set. + */ +@Deprecated +public interface SetEq extends java.util.Set { + + default boolean containsEquivalent(final Object o, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Set."); + } + + default boolean containsAllEquivalent(final Collection c, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Set."); + } + + default K getEquivalent(final Object o, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Set."); + } + + @Deprecated + interface Immutable extends SetEq { + + default Set.Immutable __insertEquivalent(final K key, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Set."); + } + + default Set.Immutable __removeEquivalent(final K key, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Set."); + } + + default Set.Immutable __insertAllEquivalent(final java.util.Set set, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Set."); + } + + default Set.Immutable __removeAllEquivalent(final java.util.Set set, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Set."); + } + + default Set.Immutable __retainAllEquivalent(final Set.Transient transientSet, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Set."); + } + + } + + @Deprecated + interface Transient extends SetEq { + + default boolean __insertEquivalent(final K key, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Set."); + } + + default boolean __removeEquivalent(final K key, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Set."); + } + + default boolean __insertAllEquivalent(final java.util.Set set, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Set."); + } + + default boolean __removeAllEquivalent(final java.util.Set set, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Set."); + } + + default boolean __retainAllEquivalent(final Set.Transient transientSet, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Set."); + } + + } +} diff --git a/capsule-core/src/main/java/io/usethesource/capsule/SetMultimap.java b/capsule-core/src/main/java/io/usethesource/capsule/SetMultimap.java new file mode 100644 index 0000000..d935114 --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/SetMultimap.java @@ -0,0 +1,219 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.util.Iterator; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.function.BiFunction; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import io.usethesource.capsule.core.PersistentTrieSetMultimap; +import io.usethesource.capsule.util.EqualityComparator; + +/** + * Experimental interface for a multimap data type. + */ +public interface SetMultimap { + + /** + * Return the number of key-value pairs contained in this multimap. + * + * @return number of key-value pairs in this multimap + */ + int size(); + + default int sizeDistinct() { + return (int) entrySet().stream().map(Entry::getKey).distinct().count(); + } + + boolean isEmpty(); + + boolean containsKey(final Object o); + + boolean containsValue(final Object o); + + boolean containsEntry(final Object o0, final Object o1); + + Set.Immutable get(final java.lang.Object o); + + java.util.Set keySet(); + + java.util.Collection values(); + + java.util.Set> entrySet(); + + Iterator keyIterator(); + + Iterator valueIterator(); + + Iterator> entryIterator(); + + // TODO: Iterator>> groupByKeyIterator(); + + /** + * Iterates over the raw internal structure. Optional operation. + * + * @return native iterator, if supported + * @throws UnsupportedOperationException, if not supported + */ + default Iterator> nativeEntryIterator() throws UnsupportedOperationException { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + Iterator tupleIterator(final BiFunction dataConverter); + + default Stream tupleStream(final BiFunction dataConverter) { + final Iterator iterator = tupleIterator(dataConverter); + + /** + * TODO: differentiate characteristics between TRANSIENT and IMMUTABLE. For the latter case add + * {@link Spliterator.IMMUTABLE}. + */ + final int characteristics = Spliterator.DISTINCT | Spliterator.SIZED; + final Spliterator spliterator = Spliterators.spliterator(iterator, size(), characteristics); + + return StreamSupport.stream(spliterator, false); + } + + /** + * Returns the hash code for this multimap. + * + * The hash code is defined to equal the hash of a {@link Set>} view (rather than + * to equal the hash code of {@link Map>}). + * + * @return the hash code for this multimap + */ + @Override + int hashCode(); + + /** + * Compares the specified object for equality against this multimap. + * + * The notion of equality is equal to the {@link Set>} view of a multimap, i.e., + * all key-value pairs have to equal. + * + * @param other the object that is checked for equality against this multimap + * @return {@code true} if the specified object is equal to this map + */ + @Override + boolean equals(Object other); + + interface Immutable extends SetMultimap, SetMultimapEq.Immutable { + + SetMultimap.Immutable __put(final K key, final V value); + + default SetMultimap.Immutable __put(final K key, final Set.Immutable values) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + SetMultimap.Immutable __insert(final K key, final V value); + + default SetMultimap.Immutable __insert(final K key, final Set.Immutable values) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + // removes all mappings with 'key' + default SetMultimap.Immutable __remove(final K key) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + SetMultimap.Immutable __remove(final K key, final V val); + + default SetMultimap.Immutable union( + final SetMultimap setMultimap) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default SetMultimap.Immutable intersect( + final SetMultimap setMultimap) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default SetMultimap.Immutable complement( + final SetMultimap setMultimap) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + boolean isTransientSupported(); + + SetMultimap.Transient asTransient(); + + static SetMultimap.Immutable of() { + return PersistentTrieSetMultimap.of(); + } + + static SetMultimap.Immutable of(K key, V value) { + return PersistentTrieSetMultimap.of(key, value); + } + + static SetMultimap.Immutable of(K key0, V value0, K key1, V value1) { + return PersistentTrieSetMultimap.of(key0, value0, key1, value1); + } + + @Deprecated + static SetMultimap.Immutable of(EqualityComparator cmp) { + return PersistentTrieSetMultimap.of(cmp); + } + + } + + /* + * TODO: consider return types for observability: i.e., either returning Immutable or boolean? + */ + interface Transient extends SetMultimap, SetMultimapEq.Transient { + + default boolean __put(final K key, final V value) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean __put(final K key, final Set.Immutable values) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + boolean __insert(final K key, final V value); + + default boolean __insert(final K key, final Set.Immutable values) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean __remove(final K key) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + boolean __remove(final K key, final V val); + + default boolean union(final SetMultimap setMultimap) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean intersect(final SetMultimap setMultimap) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean complement(final SetMultimap setMultimap) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + SetMultimap.Immutable freeze(); + + static SetMultimap.Transient of() { + return PersistentTrieSetMultimap.transientOf(); + } + + @Deprecated + static SetMultimap.Transient of(EqualityComparator cmp) { + return PersistentTrieSetMultimap.transientOf(cmp); + } + + } + +} diff --git a/capsule-core/src/main/java/io/usethesource/capsule/SetMultimapEq.java b/capsule-core/src/main/java/io/usethesource/capsule/SetMultimapEq.java new file mode 100644 index 0000000..f2918c2 --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/SetMultimapEq.java @@ -0,0 +1,130 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.util.Comparator; + +/** + * This interface extends multi-maps for usage with custom data element comparators. + */ +@Deprecated +public interface SetMultimapEq extends SetMultimap { + + default boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean containsValueEquivalent(final Object o, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean containsEntryEquivalent(final Object o0, final Object o1, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default Set.Immutable getEquivalent(final Object o, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + @Deprecated + interface Immutable extends SetMultimapEq { + + default SetMultimap.Immutable __putEquivalent(final K key, final V value, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default SetMultimap.Immutable __putEquivalent(final K key, final Set.Immutable values, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default SetMultimap.Immutable __insertEquivalent(final K key, final V value, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default SetMultimap.Immutable __insertEquivalent(final K key, + final Set.Immutable values, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default SetMultimap.Immutable __removeEquivalent(final K key, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default SetMultimap.Immutable __removeEquivalent(final K key, final V val, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default SetMultimap.Immutable unionEquivalent( + final SetMultimap setMultimap, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default SetMultimap.Immutable intersectEquivalent( + final SetMultimap setMultimap, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default SetMultimap.Immutable complementEquivalent( + final SetMultimap setMultimap, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + } + + @Deprecated + interface Transient extends SetMultimapEq { + + default boolean __putEquivalent(final K key, final V value, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean __putEquivalent(final K key, final Set.Immutable values, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean __insertEquivalent(final K key, final V value, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean __insertEquivalent(final K key, final Set.Immutable values, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean __removeEquivalent(final K key, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean __removeEquivalent(final K key, final V val, final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean unionEquivalent(final SetMultimap setMultimap, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean intersectEquivalent(final SetMultimap setMultimap, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + default boolean complementEquivalent(final SetMultimap setMultimap, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented @ Multi-Map."); + } + + } +} diff --git a/capsule-core/src/main/java/io/usethesource/capsule/core/PersistentBidirectionalTrieSetMultimap.java b/capsule-core/src/main/java/io/usethesource/capsule/core/PersistentBidirectionalTrieSetMultimap.java new file mode 100644 index 0000000..36dc314 --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/core/PersistentBidirectionalTrieSetMultimap.java @@ -0,0 +1,340 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.core; + +import java.util.Collection; +import java.util.Iterator; +import java.util.Map; +import java.util.function.BiFunction; +import java.util.stream.Stream; + +import io.usethesource.capsule.BinaryRelation; +import io.usethesource.capsule.Set; +import io.usethesource.capsule.SetMultimap; + +public class PersistentBidirectionalTrieSetMultimap implements + BinaryRelation.Immutable { + + private final SetMultimap.Immutable fwd; + private final SetMultimap.Immutable bwd; + + public PersistentBidirectionalTrieSetMultimap(final SetMultimap.Immutable fwd, + final SetMultimap.Immutable bwd) { + this.fwd = fwd; + this.bwd = bwd; + } + + public static final BinaryRelation.Immutable of() { + /* + * NOTE: uses default multi-map to create nested forward and backward maps. + * + * TODO: make classes of nested multi-maps configurable. + */ + return new PersistentBidirectionalTrieSetMultimap(SetMultimap.Immutable.of(), + SetMultimap.Immutable.of()); + } + + public static final BinaryRelation.Transient transientOf() { + /* + * NOTE: uses default multi-map to create nested forward and backward maps. + * + * TODO: make classes of nested multi-maps configurable. + */ + return new TransientBidirectionalTrieSetMultimap(SetMultimap.Transient.of(), + SetMultimap.Transient.of()); + } + + private static BinaryRelation.Immutable wireTuple(K key, V value, + final BiFunction> fwdMerger, + final BiFunction> bwdMerger) { + + return new PersistentBidirectionalTrieSetMultimap(fwdMerger.apply(key, value), + bwdMerger.apply(value, key)); + } + + @Override + public BinaryRelation inverse() { + return new PersistentBidirectionalTrieSetMultimap<>(bwd, fwd); + } + + @Override + public SetMultimap toSetMultimap() { + return fwd; + } + + @Override + public int size() { + return fwd.size(); + } + + @Override + public int sizeDistinct() { + return fwd.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return fwd.isEmpty(); + } + + @Override + public boolean containsKey(Object o) { + return fwd.containsKey(o); + } + + @Override + public boolean containsValue(Object o) { + /* + * hash lookup on inverse + */ + return bwd.containsKey(o); + } + + @Override + public boolean containsEntry(Object o0, Object o1) { + return fwd.containsEntry(o0, o1); + } + + @Override + public Set.Immutable get(Object o) { + return fwd.get(o); + } + + @Override + public java.util.Set keySet() { + return fwd.keySet(); + } + + @Override + public Collection values() { + return fwd.values(); + } + + @Override + public java.util.Set> entrySet() { + return fwd.entrySet(); + } + + @Override + public Iterator keyIterator() { + return fwd.keyIterator(); + } + + @Override + public Iterator valueIterator() { + return fwd.valueIterator(); + } + + @Override + public Iterator> entryIterator() { + return fwd.entryIterator(); + } + + @Override + public Iterator> nativeEntryIterator() throws UnsupportedOperationException { + return fwd.nativeEntryIterator(); + } + + @Override + public Iterator tupleIterator(BiFunction dataConverter) { + return fwd.tupleIterator(dataConverter); + } + + @Override + public Stream tupleStream(BiFunction dataConverter) { + return fwd.tupleStream(dataConverter); + } + + @Override + public SetMultimap.Immutable __put(K key, V value) { + return wireTuple(key, value, fwd::__put, bwd::__put); + } + + @Override + public SetMultimap.Immutable __insert(K key, V value) { + return wireTuple(key, value, fwd::__insert, bwd::__insert); + } + + @Override + public SetMultimap.Immutable __remove(K key, V value) { + return wireTuple(key, value, fwd::__remove, bwd::__remove); + } + + @Override + public int hashCode() { + return fwd.hashCode(); + } + + @Override + public boolean equals(Object other) { + return fwd.equals(other); + } + + @Override + public String toString() { + return fwd.toString(); + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public BinaryRelation.Transient asTransient() { + return new TransientBidirectionalTrieSetMultimap(fwd.asTransient(), bwd.asTransient()); + } +} + + +class TransientBidirectionalTrieSetMultimap implements BinaryRelation.Transient { + + private final SetMultimap.Transient fwd; + private transient final SetMultimap.Transient bwd; + + public TransientBidirectionalTrieSetMultimap(final SetMultimap.Transient fwd, + final SetMultimap.Transient bwd) { + this.fwd = fwd; + this.bwd = bwd; + } + + private static boolean wireTransientTuple(K key, V value, + final BiFunction fwdMerger, final BiFunction bwdMerger) { + boolean fwdResult = fwdMerger.apply(key, value); + boolean bwdResult = bwdMerger.apply(value, key); + return fwdResult || bwdResult; + } + + @Override + public BinaryRelation inverse() { + return new TransientBidirectionalTrieSetMultimap<>(bwd, fwd); + } + + @Override + public SetMultimap toSetMultimap() { + return fwd; + } + + @Override + public int size() { + return fwd.size(); + } + + @Override + public int sizeDistinct() { + return fwd.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return fwd.isEmpty(); + } + + @Override + public boolean containsKey(Object o) { + return fwd.containsKey(o); + } + + @Override + public boolean containsValue(Object o) { + /* + * hash lookup on inverse + */ + return bwd.containsKey(o); + } + + @Override + public boolean containsEntry(Object o0, Object o1) { + return fwd.containsEntry(o0, o1); + } + + @Override + public Set.Immutable get(Object o) { + return fwd.get(o); + } + + @Override + public java.util.Set keySet() { + return fwd.keySet(); + } + + @Override + public Collection values() { + return fwd.values(); + } + + @Override + public java.util.Set> entrySet() { + return fwd.entrySet(); + } + + @Override + public Iterator keyIterator() { + return fwd.keyIterator(); + } + + @Override + public Iterator valueIterator() { + return fwd.valueIterator(); + } + + @Override + public Iterator> entryIterator() { + return fwd.entryIterator(); + } + + @Override + public Iterator> nativeEntryIterator() throws UnsupportedOperationException { + return fwd.nativeEntryIterator(); + } + + @Override + public Iterator tupleIterator(BiFunction dataConverter) { + return fwd.tupleIterator(dataConverter); + } + + @Override + public Stream tupleStream(BiFunction dataConverter) { + return fwd.tupleStream(dataConverter); + } + + @Override + public boolean __put(K key, V value) { + return wireTransientTuple(key, value, fwd::__put, bwd::__put); + } + + @Override + public boolean __insert(K key, V value) { + return wireTransientTuple(key, value, fwd::__insert, bwd::__insert); + } + + @Override + public boolean __remove(K key, V value) { + return wireTransientTuple(key, value, fwd::__remove, bwd::__remove); + } + + @Override + public int hashCode() { + return fwd.hashCode(); + } + + @Override + public boolean equals(Object other) { + return fwd.equals(other); + } + + @Override + public String toString() { + return fwd.toString(); + } + + @Override + public BinaryRelation.Immutable freeze() { + return new PersistentBidirectionalTrieSetMultimap<>(fwd.freeze(), bwd.freeze()); + } +} diff --git a/src/main/java/io/usethesource/capsule/TrieMap_5Bits.java b/capsule-core/src/main/java/io/usethesource/capsule/core/PersistentTrieMap.java similarity index 93% rename from src/main/java/io/usethesource/capsule/TrieMap_5Bits.java rename to capsule-core/src/main/java/io/usethesource/capsule/core/PersistentTrieMap.java index 763781f..7216581 100644 --- a/src/main/java/io/usethesource/capsule/TrieMap_5Bits.java +++ b/capsule-core/src/main/java/io/usethesource/capsule/core/PersistentTrieMap.java @@ -5,9 +5,7 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; - -import static io.usethesource.capsule.AbstractSpecialisedImmutableMap.entryOf; +package io.usethesource.capsule.core; import java.text.DecimalFormat; import java.util.AbstractCollection; @@ -24,12 +22,16 @@ import java.util.Objects; import java.util.Set; import java.util.concurrent.atomic.AtomicReference; +import java.util.function.BiFunction; + +import io.usethesource.capsule.util.ArrayUtils; -@SuppressWarnings("rawtypes") -public class TrieMap_5Bits implements ImmutableMap { +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; - @SuppressWarnings("unchecked") - private static final TrieMap_5Bits EMPTY_MAP = new TrieMap_5Bits(CompactMapNode.EMPTY_NODE, 0, 0); +public class PersistentTrieMap implements io.usethesource.capsule.Map.Immutable { + + private static final PersistentTrieMap EMPTY_MAP = new PersistentTrieMap( + CompactMapNode.EMPTY_NODE, 0, 0); private static final boolean DEBUG = false; @@ -37,7 +39,7 @@ public class TrieMap_5Bits implements ImmutableMap { private final int hashCode; private final int cachedSize; - TrieMap_5Bits(AbstractMapNode rootNode, int hashCode, int cachedSize) { + PersistentTrieMap(AbstractMapNode rootNode, int hashCode, int cachedSize) { this.rootNode = rootNode; this.hashCode = hashCode; this.cachedSize = cachedSize; @@ -46,18 +48,17 @@ public class TrieMap_5Bits implements ImmutableMap { } } - @SuppressWarnings("unchecked") - public static final ImmutableMap of() { - return TrieMap_5Bits.EMPTY_MAP; + public static final io.usethesource.capsule.Map.Immutable of() { + return PersistentTrieMap.EMPTY_MAP; } - @SuppressWarnings("unchecked") - public static final ImmutableMap of(Object... keyValuePairs) { + public static final io.usethesource.capsule.Map.Immutable of( + Object... keyValuePairs) { if (keyValuePairs.length % 2 != 0) { throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); } - ImmutableMap result = TrieMap_5Bits.EMPTY_MAP; + io.usethesource.capsule.Map.Immutable result = PersistentTrieMap.EMPTY_MAP; for (int i = 0; i < keyValuePairs.length; i += 2) { final K key = (K) keyValuePairs[i]; @@ -69,18 +70,18 @@ public static final ImmutableMap of(Object... keyValuePairs) { return result; } - @SuppressWarnings("unchecked") - public static final TransientMap transientOf() { - return TrieMap_5Bits.EMPTY_MAP.asTransient(); + public static final io.usethesource.capsule.Map.Transient transientOf() { + return PersistentTrieMap.EMPTY_MAP.asTransient(); } - @SuppressWarnings("unchecked") - public static final TransientMap transientOf(Object... keyValuePairs) { + public static final io.usethesource.capsule.Map.Transient transientOf( + Object... keyValuePairs) { if (keyValuePairs.length % 2 != 0) { throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); } - final TransientMap result = TrieMap_5Bits.EMPTY_MAP.asTransient(); + final io.usethesource.capsule.Map.Transient result = PersistentTrieMap.EMPTY_MAP + .asTransient(); for (int i = 0; i < keyValuePairs.length; i += 2) { final K key = (K) keyValuePairs[i]; @@ -96,7 +97,7 @@ private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) int hash = 0; int size = 0; - for (Iterator> it = entryIterator(); it.hasNext();) { + for (Iterator> it = entryIterator(); it.hasNext(); ) { final Map.Entry entry = it.next(); final K key = entry.getKey(); final V val = entry.getValue(); @@ -115,7 +116,6 @@ public static final int transformHashCode(final int hash) { @Override public boolean containsKey(final Object o) { try { - @SuppressWarnings("unchecked") final K key = (K) o; return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); } catch (ClassCastException unused) { @@ -126,7 +126,6 @@ public boolean containsKey(final Object o) { @Override public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { try { - @SuppressWarnings("unchecked") final K key = (K) o; return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); } catch (ClassCastException unused) { @@ -136,7 +135,7 @@ public boolean containsKeyEquivalent(final Object o, final Comparator cm @Override public boolean containsValue(final Object o) { - for (Iterator iterator = valueIterator(); iterator.hasNext();) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { if (iterator.next().equals(o)) { return true; } @@ -146,7 +145,7 @@ public boolean containsValue(final Object o) { @Override public boolean containsValueEquivalent(final Object o, final Comparator cmp) { - for (Iterator iterator = valueIterator(); iterator.hasNext();) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { if (cmp.compare(iterator.next(), o) == 0) { return true; } @@ -157,7 +156,6 @@ public boolean containsValueEquivalent(final Object o, final Comparator @Override public V get(final Object o) { try { - @SuppressWarnings("unchecked") final K key = (K) o; final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); @@ -174,7 +172,6 @@ public V get(final Object o) { @Override public V getEquivalent(final Object o, final Comparator cmp) { try { - @SuppressWarnings("unchecked") final K key = (K) o; final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); @@ -189,7 +186,7 @@ public V getEquivalent(final Object o, final Comparator cmp) { } @Override - public ImmutableMap __put(final K key, final V val) { + public io.usethesource.capsule.Map.Immutable __put(final K key, final V val) { final int keyHash = key.hashCode(); final MapResult details = MapResult.unchanged(); @@ -201,19 +198,20 @@ public ImmutableMap __put(final K key, final V val) { final int valHashOld = details.getReplacedValue().hashCode(); final int valHashNew = val.hashCode(); - return new TrieMap_5Bits(newRootNode, + return new PersistentTrieMap(newRootNode, hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); } final int valHash = val.hashCode(); - return new TrieMap_5Bits(newRootNode, hashCode + ((keyHash ^ valHash)), cachedSize + 1); + return new PersistentTrieMap(newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1); } return this; } @Override - public ImmutableMap __putEquivalent(final K key, final V val, + public io.usethesource.capsule.Map.Immutable __putEquivalent(final K key, final V val, final Comparator cmp) { final int keyHash = key.hashCode(); final MapResult details = MapResult.unchanged(); @@ -226,34 +224,37 @@ public ImmutableMap __putEquivalent(final K key, final V val, final int valHashOld = details.getReplacedValue().hashCode(); final int valHashNew = val.hashCode(); - return new TrieMap_5Bits(newRootNode, + return new PersistentTrieMap(newRootNode, hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); } final int valHash = val.hashCode(); - return new TrieMap_5Bits(newRootNode, hashCode + ((keyHash ^ valHash)), cachedSize + 1); + return new PersistentTrieMap(newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1); } return this; } @Override - public ImmutableMap __putAll(final Map map) { - final TransientMap tmpTransient = this.asTransient(); + public io.usethesource.capsule.Map.Immutable __putAll( + final Map map) { + final io.usethesource.capsule.Map.Transient tmpTransient = this.asTransient(); tmpTransient.__putAll(map); return tmpTransient.freeze(); } @Override - public ImmutableMap __putAllEquivalent(final Map map, + public io.usethesource.capsule.Map.Immutable __putAllEquivalent( + final Map map, final Comparator cmp) { - final TransientMap tmpTransient = this.asTransient(); + final io.usethesource.capsule.Map.Transient tmpTransient = this.asTransient(); tmpTransient.__putAllEquivalent(map, cmp); return tmpTransient.freeze(); } @Override - public ImmutableMap __remove(final K key) { + public io.usethesource.capsule.Map.Immutable __remove(final K key) { final int keyHash = key.hashCode(); final MapResult details = MapResult.unchanged(); @@ -263,14 +264,16 @@ public ImmutableMap __remove(final K key) { if (details.isModified()) { assert details.hasReplacedValue(); final int valHash = details.getReplacedValue().hashCode(); - return new TrieMap_5Bits(newRootNode, hashCode - ((keyHash ^ valHash)), cachedSize - 1); + return new PersistentTrieMap(newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); } return this; } @Override - public ImmutableMap __removeEquivalent(final K key, final Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __removeEquivalent(final K key, + final Comparator cmp) { final int keyHash = key.hashCode(); final MapResult details = MapResult.unchanged(); @@ -280,7 +283,8 @@ public ImmutableMap __removeEquivalent(final K key, final Comparator(newRootNode, hashCode - ((keyHash ^ valHash)), cachedSize - 1); + return new PersistentTrieMap(newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); } return this; @@ -339,27 +343,27 @@ public Set keySet() { keySet = new AbstractSet() { @Override public Iterator iterator() { - return TrieMap_5Bits.this.keyIterator(); + return PersistentTrieMap.this.keyIterator(); } @Override public int size() { - return TrieMap_5Bits.this.size(); + return PersistentTrieMap.this.size(); } @Override public boolean isEmpty() { - return TrieMap_5Bits.this.isEmpty(); + return PersistentTrieMap.this.isEmpty(); } @Override public void clear() { - TrieMap_5Bits.this.clear(); + PersistentTrieMap.this.clear(); } @Override public boolean contains(Object k) { - return TrieMap_5Bits.this.containsKey(k); + return PersistentTrieMap.this.containsKey(k); } }; } @@ -375,27 +379,27 @@ public Collection values() { values = new AbstractCollection() { @Override public Iterator iterator() { - return TrieMap_5Bits.this.valueIterator(); + return PersistentTrieMap.this.valueIterator(); } @Override public int size() { - return TrieMap_5Bits.this.size(); + return PersistentTrieMap.this.size(); } @Override public boolean isEmpty() { - return TrieMap_5Bits.this.isEmpty(); + return PersistentTrieMap.this.isEmpty(); } @Override public void clear() { - TrieMap_5Bits.this.clear(); + PersistentTrieMap.this.clear(); } @Override public boolean contains(Object v) { - return TrieMap_5Bits.this.containsValue(v); + return PersistentTrieMap.this.containsValue(v); } }; } @@ -433,22 +437,22 @@ public void remove() { @Override public int size() { - return TrieMap_5Bits.this.size(); + return PersistentTrieMap.this.size(); } @Override public boolean isEmpty() { - return TrieMap_5Bits.this.isEmpty(); + return PersistentTrieMap.this.isEmpty(); } @Override public void clear() { - TrieMap_5Bits.this.clear(); + PersistentTrieMap.this.clear(); } @Override public boolean contains(Object k) { - return TrieMap_5Bits.this.containsKey(k); + return PersistentTrieMap.this.containsKey(k); } }; } @@ -465,8 +469,8 @@ public boolean equals(final Object other) { return false; } - if (other instanceof TrieMap_5Bits) { - TrieMap_5Bits that = (TrieMap_5Bits) other; + if (other instanceof PersistentTrieMap) { + PersistentTrieMap that = (PersistentTrieMap) other; if (this.cachedSize != that.cachedSize) { return false; @@ -484,19 +488,17 @@ public boolean equals(final Object other) { return false; } - for (@SuppressWarnings("unchecked") - Iterator it = that.entrySet().iterator(); it.hasNext();) { + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { Map.Entry entry = it.next(); try { - @SuppressWarnings("unchecked") final K key = (K) entry.getKey(); final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); if (!result.isPresent()) { return false; } else { - @SuppressWarnings("unchecked") final V val = (V) entry.getValue(); if (!result.get().equals(val)) { @@ -519,13 +521,21 @@ public int hashCode() { return hashCode; } + @Override + public String toString() { + String body = + entrySet().stream().map(entry -> String.format("%s: %s", entry.getKey(), entry.getValue())) + .reduce((o1, o2) -> String.join(", ", o1, o2)).orElse(""); + return String.format("{%s}", body); + } + @Override public boolean isTransientSupported() { return true; } @Override - public TransientMap asTransient() { + public io.usethesource.capsule.Map.Transient asTransient() { return new TransientTrieMap_5Bits(this); } @@ -634,6 +644,7 @@ public void printStatistics() { } abstract static class Optional { + private static final Optional EMPTY = new Optional() { @Override boolean isPresent() { @@ -646,7 +657,6 @@ Object get() { } }; - @SuppressWarnings("unchecked") static Optional empty() { return EMPTY; } @@ -660,6 +670,7 @@ static Optional of(T value) { abstract T get(); private static final class Value extends Optional { + private final T value; private Value(T value) { @@ -679,6 +690,7 @@ T get() { } static final class MapResult { + private V replacedValue; private boolean isModified; private boolean isReplaced; @@ -699,7 +711,8 @@ public static MapResult unchanged() { return new MapResult<>(); } - private MapResult() {} + private MapResult() { + } public boolean isModified() { return isModified; @@ -715,6 +728,7 @@ public V getReplacedValue() { } protected static interface INode { + } protected static abstract class AbstractMapNode implements INode { @@ -894,8 +908,8 @@ static final CompactMapNode mergeTwoKeyValPairs(final K key0, final if (shift >= HASH_CODE_LENGTH) { // throw new // IllegalStateException("Hash collision not yet fixed."); - return new HashCollisionMapNode_5Bits<>(keyHash0, (K[]) new Object[] {key0, key1}, - (V[]) new Object[] {val0, val1}); + return new HashCollisionMapNode_5Bits<>(keyHash0, (K[]) new Object[]{key0, key1}, + (V[]) new Object[]{val0, val1}); } final int mask0 = mask(keyHash0, shift); @@ -906,9 +920,9 @@ static final CompactMapNode mergeTwoKeyValPairs(final K key0, final final int dataMap = bitpos(mask0) | bitpos(mask1); if (mask0 < mask1) { - return nodeOf(null, (0), dataMap, new Object[] {key0, val0, key1, val1}); + return nodeOf(null, (0), dataMap, new Object[]{key0, val0, key1, val1}); } else { - return nodeOf(null, (0), dataMap, new Object[] {key1, val1, key0, val0}); + return nodeOf(null, (0), dataMap, new Object[]{key1, val1, key0, val0}); } } else { final CompactMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, @@ -916,7 +930,7 @@ static final CompactMapNode mergeTwoKeyValPairs(final K key0, final // values fit on next level final int nodeMap = bitpos(mask0); - return nodeOf(null, nodeMap, (0), new Object[] {node}); + return nodeOf(null, nodeMap, (0), new Object[]{node}); } } @@ -924,16 +938,17 @@ static final CompactMapNode mergeTwoKeyValPairs(final K key0, final static { - EMPTY_NODE = new BitmapIndexedMapNode<>(null, (0), (0), new Object[] {}); + EMPTY_NODE = new BitmapIndexedMapNode<>(null, (0), (0), new Object[]{}); - }; + } + + ; static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, final int dataMap, final Object[] nodes) { return new BitmapIndexedMapNode<>(mutator, nodeMap, dataMap, nodes); } - @SuppressWarnings("unchecked") static final CompactMapNode nodeOf(AtomicReference mutator) { return EMPTY_NODE; } @@ -941,7 +956,7 @@ static final CompactMapNode nodeOf(AtomicReference mutator) static final CompactMapNode nodeOf(AtomicReference mutator, final int nodeMap, final int dataMap, final K key, final V val) { assert nodeMap == 0; - return nodeOf(mutator, (0), dataMap, new Object[] {key, val}); + return nodeOf(mutator, (0), dataMap, new Object[]{key, val}); } static final int index(final int bitmap, final int bitpos) { @@ -1163,11 +1178,9 @@ CompactMapNode removed(final AtomicReference mutator, final K key, (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); if (dataIndex == 0) { - return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(1), - getValue(1)); + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(1), getValue(1)); } else { - return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(0), - getValue(0)); + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(0), getValue(0)); } } else { return copyAndRemoveValue(mutator, bitpos); @@ -1230,11 +1243,9 @@ CompactMapNode removed(final AtomicReference mutator, final K key, (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); if (dataIndex == 0) { - return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(1), - getValue(1)); + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(1), getValue(1)); } else { - return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(0), - getValue(0)); + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(0), getValue(0)); } } else { return copyAndRemoveValue(mutator, bitpos); @@ -1370,7 +1381,6 @@ private BitmapIndexedMapNode(final AtomicReference mutator, final int no this.nodes = nodes; if (DEBUG) { - assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + java.lang.Integer.bitCount(nodeMap) == nodes.length); @@ -1380,18 +1390,16 @@ private BitmapIndexedMapNode(final AtomicReference mutator, final int no for (int i = TUPLE_LENGTH * payloadArity(); i < nodes.length; i++) { assert ((nodes[i] instanceof CompactMapNode) == true); } - } - assert nodeInvariant(); + assert nodeInvariant(); + } } - @SuppressWarnings("unchecked") @Override K getKey(final int index) { return (K) nodes[TUPLE_LENGTH * index]; } - @SuppressWarnings("unchecked") @Override V getValue(final int index) { return (V) nodes[TUPLE_LENGTH * index + 1]; @@ -1402,7 +1410,6 @@ Map.Entry getKeyValueEntry(final int index) { return entryOf((K) nodes[TUPLE_LENGTH * index], (V) nodes[TUPLE_LENGTH * index + 1]); } - @SuppressWarnings("unchecked") @Override CompactMapNode getNode(final int index) { return (CompactMapNode) nodes[nodes.length - 1 - index]; @@ -1614,6 +1621,7 @@ CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference extends CompactMapNode { + private final K[] keys; private final V[] vals; private final int hash; @@ -1690,7 +1698,6 @@ CompactMapNode updated(final AtomicReference mutator, final K key, } else { // add new mapping final V[] src = this.vals; - @SuppressWarnings("unchecked") final V[] dst = (V[]) new Object[src.length]; // copy 'src' and set 1 element(s) at position 'idx' @@ -1706,7 +1713,6 @@ CompactMapNode updated(final AtomicReference mutator, final K key, } } - @SuppressWarnings("unchecked") final K[] keysNew = (K[]) new Object[this.keys.length + 1]; // copy 'this.keys' and insert 1 element(s) at position @@ -1716,7 +1722,6 @@ CompactMapNode updated(final AtomicReference mutator, final K key, System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, this.keys.length - keys.length); - @SuppressWarnings("unchecked") final V[] valsNew = (V[]) new Object[this.vals.length + 1]; // copy 'this.vals' and insert 1 element(s) at position @@ -1745,7 +1750,6 @@ CompactMapNode updated(final AtomicReference mutator, final K key, } else { // add new mapping final V[] src = this.vals; - @SuppressWarnings("unchecked") final V[] dst = (V[]) new Object[src.length]; // copy 'src' and set 1 element(s) at position 'idx' @@ -1761,7 +1765,6 @@ CompactMapNode updated(final AtomicReference mutator, final K key, } } - @SuppressWarnings("unchecked") final K[] keysNew = (K[]) new Object[this.keys.length + 1]; // copy 'this.keys' and insert 1 element(s) at position @@ -1771,7 +1774,6 @@ CompactMapNode updated(final AtomicReference mutator, final K key, System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, this.keys.length - keys.length); - @SuppressWarnings("unchecked") final V[] valsNew = (V[]) new Object[this.vals.length + 1]; // copy 'this.vals' and insert 1 element(s) at position @@ -1805,7 +1807,6 @@ CompactMapNode removed(final AtomicReference mutator, final K key, return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, keyHash, 0, details); } else { - @SuppressWarnings("unchecked") final K[] keysNew = (K[]) new Object[this.keys.length - 1]; // copy 'this.keys' and remove 1 element(s) at position @@ -1813,7 +1814,6 @@ CompactMapNode removed(final AtomicReference mutator, final K key, System.arraycopy(this.keys, 0, keysNew, 0, idx); System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); - @SuppressWarnings("unchecked") final V[] valsNew = (V[]) new Object[this.vals.length - 1]; // copy 'this.vals' and remove 1 element(s) at position @@ -1849,7 +1849,6 @@ CompactMapNode removed(final AtomicReference mutator, final K key, return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, keyHash, 0, details, cmp); } else { - @SuppressWarnings("unchecked") final K[] keysNew = (K[]) new Object[this.keys.length - 1]; // copy 'this.keys' and remove 1 element(s) at position @@ -1857,7 +1856,6 @@ CompactMapNode removed(final AtomicReference mutator, final K key, System.arraycopy(this.keys, 0, keysNew, 0, idx); System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); - @SuppressWarnings("unchecked") final V[] valsNew = (V[]) new Object[this.vals.length - 1]; // copy 'this.vals' and remove 1 element(s) at position @@ -1972,7 +1970,8 @@ public boolean equals(Object other) { /* * Linear scan for each key, because of arbitrary element order. */ - outerLoop: for (int i = 0; i < that.payloadArity(); i++) { + outerLoop: + for (int i = 0; i < that.payloadArity(); i++) { final Object otherKey = that.getKey(i); final Object otherVal = that.getValue(i); @@ -2052,7 +2051,6 @@ private static abstract class AbstractMapIterator { private int currentStackLevel = -1; private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; - @SuppressWarnings("unchecked") AbstractMapNode[] nodes = new AbstractMapNode[MAX_DEPTH]; AbstractMapIterator(AbstractMapNode rootNode) { @@ -2232,13 +2230,15 @@ public void remove() { } } - static final class TransientTrieMap_5Bits implements TransientMap { + static final class TransientTrieMap_5Bits implements + io.usethesource.capsule.Map.Transient { + final private AtomicReference mutator; private AbstractMapNode rootNode; private int hashCode; private int cachedSize; - TransientTrieMap_5Bits(TrieMap_5Bits trieMap_5Bits) { + TransientTrieMap_5Bits(PersistentTrieMap trieMap_5Bits) { this.mutator = new AtomicReference(Thread.currentThread()); this.rootNode = trieMap_5Bits.rootNode; this.hashCode = trieMap_5Bits.hashCode; @@ -2252,7 +2252,7 @@ private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) int hash = 0; int size = 0; - for (Iterator> it = entryIterator(); it.hasNext();) { + for (Iterator> it = entryIterator(); it.hasNext(); ) { final Map.Entry entry = it.next(); final K key = entry.getKey(); final V val = entry.getValue(); @@ -2266,7 +2266,12 @@ private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) @Override public V put(final K key, final V val) { - throw new UnsupportedOperationException(); + /** + * Delegation added to support {@link Map#compute(Object, BiFunction)}. + */ + return __put(key, val); + + // throw new UnsupportedOperationException(); } @Override @@ -2287,7 +2292,6 @@ public V remove(final Object key) { @Override public boolean containsKey(final Object o) { try { - @SuppressWarnings("unchecked") final K key = (K) o; return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); } catch (ClassCastException unused) { @@ -2298,7 +2302,6 @@ public boolean containsKey(final Object o) { @Override public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { try { - @SuppressWarnings("unchecked") final K key = (K) o; return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); } catch (ClassCastException unused) { @@ -2308,7 +2311,7 @@ public boolean containsKeyEquivalent(final Object o, final Comparator cm @Override public boolean containsValue(final Object o) { - for (Iterator iterator = valueIterator(); iterator.hasNext();) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { if (iterator.next().equals(o)) { return true; } @@ -2318,7 +2321,7 @@ public boolean containsValue(final Object o) { @Override public boolean containsValueEquivalent(final Object o, final Comparator cmp) { - for (Iterator iterator = valueIterator(); iterator.hasNext();) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { if (cmp.compare(iterator.next(), o) == 0) { return true; } @@ -2329,7 +2332,6 @@ public boolean containsValueEquivalent(final Object o, final Comparator @Override public V get(final Object o) { try { - @SuppressWarnings("unchecked") final K key = (K) o; final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); @@ -2346,7 +2348,6 @@ public V get(final Object o) { @Override public V getEquivalent(final Object o, final Comparator cmp) { try { - @SuppressWarnings("unchecked") final K key = (K) o; final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); @@ -2576,6 +2577,7 @@ public Iterator> entryIterator() { } public static class TransientMapKeyIterator extends MapKeyIterator { + final TransientTrieMap_5Bits collection; K lastKey; @@ -2597,6 +2599,7 @@ public void remove() { } public static class TransientMapValueIterator extends MapValueIterator { + final TransientTrieMap_5Bits collection; public TransientMapValueIterator(final TransientTrieMap_5Bits collection) { @@ -2616,6 +2619,7 @@ public void remove() { } public static class TransientMapEntryIterator extends MapEntryIterator { + final TransientTrieMap_5Bits collection; public TransientMapEntryIterator(final TransientTrieMap_5Bits collection) { @@ -2787,12 +2791,11 @@ public boolean equals(final Object other) { return false; } - for (@SuppressWarnings("unchecked") - Iterator it = that.entrySet().iterator(); it.hasNext();) { + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { Map.Entry entry = it.next(); try { - @SuppressWarnings("unchecked") final K key = (K) entry.getKey(); final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); @@ -2800,7 +2803,6 @@ public boolean equals(final Object other) { if (!result.isPresent()) { return false; } else { - @SuppressWarnings("unchecked") final V val = (V) entry.getValue(); if (!result.get().equals(val)) { @@ -2824,13 +2826,13 @@ public int hashCode() { } @Override - public ImmutableMap freeze() { + public io.usethesource.capsule.Map.Immutable freeze() { if (mutator.get() == null) { throw new IllegalStateException("Transient already frozen."); } mutator.set(null); - return new TrieMap_5Bits(rootNode, hashCode, cachedSize); + return new PersistentTrieMap(rootNode, hashCode, cachedSize); } } diff --git a/capsule-core/src/main/java/io/usethesource/capsule/core/PersistentTrieSet.java b/capsule-core/src/main/java/io/usethesource/capsule/core/PersistentTrieSet.java new file mode 100644 index 0000000..82f5f90 --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/core/PersistentTrieSet.java @@ -0,0 +1,2553 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.core; + +import java.text.DecimalFormat; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.concurrent.atomic.AtomicReference; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import io.usethesource.capsule.Set; +import io.usethesource.capsule.core.trie.ArrayView; +import io.usethesource.capsule.core.trie.Node; +import io.usethesource.capsule.util.ArrayUtils; + +public class PersistentTrieSet implements Set.Immutable { + + private static final PersistentTrieSet EMPTY_SET = new PersistentTrieSet( + CompactSetNode.EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractSetNode rootNode; + private final int hashCode; + private final int cachedSize; + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ PersistentTrieSet(AbstractSetNode rootNode) { + this.rootNode = rootNode; + this.hashCode = hashCode(rootNode); + this.cachedSize = size(rootNode); + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ PersistentTrieSet(AbstractSetNode rootNode, int hashCode, + int cachedSize) { + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final Set.Immutable of() { + return PersistentTrieSet.EMPTY_SET; + } + + public static final Set.Immutable of(K key0) { + final int keyHash0 = key0.hashCode(); + + final int nodeMap = 0; + final int dataMap = CompactSetNode.bitpos(CompactSetNode.mask(keyHash0, 0)); + + CompactSetNode newRootNode = CompactSetNode.nodeOf(null, nodeMap, dataMap, key0); + + return new PersistentTrieSet(newRootNode, keyHash0, 1); + } + + public static final Set.Immutable of(K key0, K key1) { + assert !Objects.equals(key0, key1); + + final int keyHash0 = key0.hashCode(); + final int keyHash1 = key1.hashCode(); + + CompactSetNode newRootNode = + CompactSetNode.mergeTwoKeyValPairs(key0, keyHash0, key1, keyHash1, 0); + + return new PersistentTrieSet(newRootNode, keyHash0 + keyHash1, 2); + } + + public static final Set.Immutable of(K... keys) { + Set.Immutable result = PersistentTrieSet.EMPTY_SET; + + for (final K key : keys) { + result = result.__insert(key); + } + + return result; + } + + public static final Set.Transient transientOf() { + return PersistentTrieSet.EMPTY_SET.asTransient(); + } + + public static final Set.Transient transientOf(K... keys) { + final Set.Transient result = PersistentTrieSet.EMPTY_SET.asTransient(); + + for (final K key : keys) { + result.__insert(key); + } + + return result; + } + + private static int hashCode(AbstractSetNode rootNode) { + int hash = 0; + + for (Iterator it = new SetKeyIterator<>(rootNode); it.hasNext(); ) { + hash += it.next().hashCode(); + } + + return hash; + } + + private static int size(AbstractSetNode rootNode) { + int size = 0; + + for (Iterator it = new SetKeyIterator<>(rootNode); it.hasNext(); it.next()) { + size += 1; + } + + return size; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator it = keyIterator(); it.hasNext(); ) { + final K key = it.next(); + + hash += key.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean contains(final Object o) { + try { + final K key = (K) o; + return rootNode.contains(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + return rootNode.contains(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public K get(final Object o) { + try { + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public K getEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public Set.Immutable __insert(final K key) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + return new PersistentTrieSet(newRootNode, hashCode + keyHash, cachedSize + 1); + } + + return this; + } + + @Override + public Set.Immutable __insertEquivalent(final K key, final Comparator cmp) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + return new PersistentTrieSet(newRootNode, hashCode + keyHash, cachedSize + 1); + } + + return this; + } + + @Override + public Set.Immutable __insertAll(final java.util.Set set) { + final Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__insertAll(set); + return tmpTransient.freeze(); + } + + @Override + public Set.Immutable __insertAllEquivalent(final java.util.Set set, + final Comparator cmp) { + final Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__insertAllEquivalent(set, cmp); + return tmpTransient.freeze(); + } + + @Override + public Set.Immutable __remove(final K key) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + return new PersistentTrieSet(newRootNode, hashCode - keyHash, cachedSize - 1); + } + + return this; + } + + @Override + public Set.Immutable __removeEquivalent(final K key, final Comparator cmp) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + return new PersistentTrieSet(newRootNode, hashCode - keyHash, cachedSize - 1); + } + + return this; + } + + @Override + public Set.Immutable __removeAll(final java.util.Set set) { + final Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__removeAll(set); + return tmpTransient.freeze(); + } + + @Override + public Set.Immutable __removeAllEquivalent(final java.util.Set set, + final Comparator cmp) { + final Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__removeAllEquivalent(set, cmp); + return tmpTransient.freeze(); + } + + @Override + public Set.Immutable __retainAll(final java.util.Set set) { + final Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__retainAll(set); + return tmpTransient.freeze(); + } + + @Override + public Set.Immutable __retainAllEquivalent(final Set.Transient transientSet, + final Comparator cmp) { + final Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__retainAllEquivalent(transientSet, cmp); + return tmpTransient.freeze(); + } + + @Override + public boolean add(final K key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean addAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean remove(final Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean removeAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean retainAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean containsAll(final Collection c) { + for (Object item : c) { + if (!contains(item)) { + return false; + } + } + return true; + } + + @Override + public boolean containsAllEquivalent(final Collection c, final Comparator cmp) { + for (Object item : c) { + if (!containsEquivalent(item, cmp)) { + return false; + } + } + return true; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator iterator() { + return keyIterator(); + } + + @Override + public Iterator keyIterator() { + return new SetKeyIterator<>(rootNode); + } + + @Override + public Object[] toArray() { + Object[] array = new Object[cachedSize]; + + int idx = 0; + for (K key : this) { + array[idx++] = key; + } + + return array; + } + + @Override + public T[] toArray(final T[] a) { + List list = new ArrayList(cachedSize); + + for (K key : this) { + list.add(key); + } + + return list.toArray(a); + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof PersistentTrieSet) { + PersistentTrieSet that = (PersistentTrieSet) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof java.util.Set) { + java.util.Set that = (java.util.Set) other; + + if (this.size() != that.size()) { + return false; + } + + return containsAll(that); + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public String toString() { + String body = stream().map(k -> k.toString()).reduce((o1, o2) -> String.join(", ", o1, o2)) + .orElse(""); + return String.format("{%s}", body); + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public Set.Transient asTransient() { + return new TransientTrieSet_5Bits(this); + } + + /* + * For analysis purposes only. + * + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ AbstractSetNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieSet_5BitsNodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. Payload X Node + */ + protected int[][] arityCombinationsHistogram() { + final Iterator> it = nodeIterator(); + final int[][] sumArityCombinations = new int[33][33]; + + while (it.hasNext()) { + final AbstractSetNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[33]; + + final int maxArity = 32; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[33]; + for (int cumsum = 0, i = 0; i < 33; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 33; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + abstract static class Optional { + + private static final Optional EMPTY = new Optional() { + @Override + boolean isPresent() { + return false; + } + + @Override + Object get() { + return null; + } + }; + + static Optional empty() { + return EMPTY; + } + + static Optional of(T value) { + return new Value(value); + } + + abstract boolean isPresent(); + + abstract T get(); + + private static final class Value extends Optional { + + private final T value; + + private Value(T value) { + this.value = value; + } + + @Override + boolean isPresent() { + return true; + } + + @Override + T get() { + return value; + } + } + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public static final class SetResult { + + private K replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(K replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static SetResult unchanged() { + return new SetResult<>(); + } + + private SetResult() { + } + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public K getReplacedValue() { + return replacedValue; + } + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ static abstract class AbstractSetNode implements Node, Iterable { + + static final int TUPLE_LENGTH = 1; + + // factory method to construct trie from outer classes + // TODO: find alternative solution that does not violate information hiding + public static AbstractSetNode newHashCollisonNode(final int hash, K... keys) { + return new HashCollisionSetNode_5Bits<>(hash, keys); + } + + // factory method to construct trie from outer classes + // TODO: find alternative solution that does not violate information hiding + public static AbstractSetNode newBitmapIndexedNode(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object[] content) { + // content is assumed to be effectivle immutable to avoid defensive copying + return new BitmapIndexedSetNode<>(mutator, nodeMap, dataMap, content); + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public abstract boolean contains(final K key, final int keyHash, final int shift); + + abstract boolean contains(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final K key, final int keyHash, final int shift); + + abstract Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ abstract CompactSetNode updated(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetResult details); + + abstract CompactSetNode updated(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetResult details, + final Comparator cmp); + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ abstract CompactSetNode removed(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetResult details); + + abstract CompactSetNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetResult details, + final Comparator cmp); + + // static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + // return x != null && y != null && (x == y || x.get() == y.get()); + // } + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + @Override + public abstract ArrayView> nodeArray(); + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractSetNode getNode(final int index); + +// /* +// * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to +// * `protected` when experiments are finished. +// */ +// public /* protected */ abstract void setNode(final AtomicReference mutator, +// final int index, final AbstractSetNode node); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractSetNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractSetNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractSetNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract K getKey(final int index); + + @Deprecated + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ int size() { + final Iterator it = new SetKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + + @Override + public Iterator iterator() { + return new SetKeyIterator<>(this); + } + + @Override + public Spliterator spliterator() { + return Spliterators.spliteratorUnknownSize(iterator(), Spliterator.DISTINCT); + } + + public Stream stream() { + return StreamSupport.stream(spliterator(), false); + } + + } + + protected static abstract class CompactSetNode extends AbstractSetNode { + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + abstract int nodeMap(); + + abstract int dataMap(); + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactSetNode getNode(final int index); + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactSetNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final K key); + + abstract CompactSetNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos); + + abstract CompactSetNode copyAndSetNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node); + + abstract CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node); + + abstract CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node); + + static final CompactSetNode mergeTwoKeyValPairs(final K key0, final int keyHash0, + final K key1, final int keyHash1, final int shift) { + assert !(key0.equals(key1)); + + if (shift >= HASH_CODE_LENGTH) { + // throw new + // IllegalStateException("Hash collision not yet fixed."); + return new HashCollisionSetNode_5Bits<>(keyHash0, (K[]) new Object[]{key0, key1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int dataMap = bitpos(mask0) | bitpos(mask1); + + if (mask0 < mask1) { + return nodeOf(null, (0), dataMap, new Object[]{key0, key1}); + } else { + return nodeOf(null, (0), dataMap, new Object[]{key1, key0}); + } + } else { + final CompactSetNode node = + mergeTwoKeyValPairs(key0, keyHash0, key1, keyHash1, shift + BIT_PARTITION_SIZE); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf(null, nodeMap, (0), new Object[]{node}); + } + } + + static final CompactSetNode EMPTY_NODE; + + static { + + EMPTY_NODE = new BitmapIndexedSetNode<>(null, (0), (0), new Object[]{}); + + } + + ; + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object[] nodes) { + return new BitmapIndexedSetNode<>(mutator, nodeMap, dataMap, nodes); + } + + static final CompactSetNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactSetNode nodeOf(AtomicReference mutator, final int nodeMap, + final int dataMap, final K key) { + assert nodeMap == 0; + return nodeOf(mutator, (0), dataMap, new Object[]{key}); + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + CompactSetNode nodeAt(final int bitpos) { + return getNode(nodeIndex(bitpos)); + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + @Override + public /* protected */ boolean contains(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index).equals(key); + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).contains(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return false; + } + + @Override + boolean contains(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return cmp.compare(getKey(index), key) == 0; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).contains(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index).equals(key)) { + return Optional.of(getKey(index)); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractSetNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (cmp.compare(getKey(index), key) == 0) { + return Optional.of(getKey(index)); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractSetNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return Optional.empty(); + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + @Override + public /* protected */ CompactSetNode updated(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (currentKey.equals(key)) { + return this; + } else { + final CompactSetNode subNodeNew = mergeTwoKeyValPairs(currentKey, + transformHashCode(currentKey.hashCode()), key, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.updated(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key); + } + } + + @Override + CompactSetNode updated(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (cmp.compare(currentKey, key) == 0) { + return this; + } else { + final CompactSetNode subNodeNew = mergeTwoKeyValPairs(currentKey, + transformHashCode(currentKey.hashCode()), key, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.updated(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key); + } + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + @Override + public /* protected */ CompactSetNode removed(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex).equals(key)) { + details.modified(); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactSetNode.nodeOf(mutator, 0, newDataMap, getKey(1)); + } else { + return CompactSetNode.nodeOf(mutator, 0, newDataMap, getKey(0)); + } + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (this.payloadArity() == 0 && this.nodeArity() == 1) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + @Override + CompactSetNode removed(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (cmp.compare(getKey(dataIndex), key) == 0) { + details.modified(); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactSetNode.nodeOf(mutator, 0, newDataMap, getKey(1)); + } else { + return CompactSetNode.nodeOf(mutator, 0, newDataMap, getKey(0)); + } + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (this.payloadArity() == 0 && this.nodeArity() == 1) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d<#%d>", pos, Objects.hashCode(getKey(i)))); + + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedSetNode extends CompactSetNode { + + private final int nodeMap; + private final int dataMap; + + CompactMixedSetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + this.dataMap = dataMap; + } + + @Override + final int nodeMap() { + return nodeMap; + } + + @Override + final int dataMap() { + return dataMap; + } + + } + + private static final class BitmapIndexedSetNode extends CompactMixedSetNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedSetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + super(mutator, nodeMap, dataMap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < TUPLE_LENGTH * payloadArity(); i++) { + assert ((nodes[i] instanceof CompactSetNode) == false); + } + for (int i = TUPLE_LENGTH * payloadArity(); i < nodes.length; i++) { + assert ((nodes[i] instanceof CompactSetNode) == true); + } + + assert nodeInvariant(); + } + } + + @Override + public ArrayView> nodeArray() { + return new ArrayView>() { + @Override + public int size() { + return BitmapIndexedSetNode.this.nodeArity(); + } + + @Override + public AbstractSetNode get(int index) { + return BitmapIndexedSetNode.this.getNode(index); + } + + @Override + public void set(int index, AbstractSetNode item) { + // if (!isAllowedToEdit(BitmapIndexedSetNode.this.mutator, writeCapabilityToken)) { + // throw new IllegalStateException(); + // } + + nodes[nodes.length - 1 - index] = item; + } + + @Override + public void set(int index, AbstractSetNode item, + AtomicReference writeCapabilityToken) { + if (!isAllowedToEdit(BitmapIndexedSetNode.this.mutator, writeCapabilityToken)) { + throw new IllegalStateException(); + } + + nodes[nodes.length - 1 - index] = item; + } + }; + } + + @Override + K getKey(final int index) { + return (K) nodes[TUPLE_LENGTH * index]; + } + + @Override + CompactSetNode getNode(final int index) { + return (CompactSetNode) nodes[nodes.length - 1 - index]; + } + +// @Override +// public void setNode(final AtomicReference mutator, final int index, +// final AbstractSetNode node) { +// if (isAllowedToEdit(this.mutator, mutator)) { +// nodes[nodes.length - 1 - index] = node; +// } else { +// throw new IllegalStateException(); +// } +// } + + @Override + boolean hasPayload() { + return dataMap() != 0; + } + + @Override + int payloadArity() { + return java.lang.Integer.bitCount(dataMap()); + } + + @Override + boolean hasNodes() { + return nodeMap() != 0; + } + + @Override + int nodeArity() { + return java.lang.Integer.bitCount(nodeMap()); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + (nodeMap()); + result = prime * result + (dataMap()); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedSetNode that = (BitmapIndexedSetNode) other; + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + if (!ArrayUtils.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + if (this.nodeArity() == 0) { + switch (this.payloadArity()) { + case 0: + return SIZE_EMPTY; + case 1: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } else { + return SIZE_MORE_THAN_ONE; + } + } + + @Override + CompactSetNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactSetNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(bitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactSetNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length + 1]; + + // copy 'src' and insert 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + System.arraycopy(src, idx, dst, idx + 1, src.length - idx); + + return nodeOf(mutator, nodeMap(), dataMap() | bitpos, dst); + } + + @Override + CompactSetNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1]; + + // copy 'src' and remove 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 1, dst, idx, src.length - idx - 1); + + return nodeOf(mutator, nodeMap(), dataMap() ^ bitpos, dst); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 1]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 1, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 1, dst, idxNew + 1, src.length - idxNew - 1); + + return nodeOf(mutator, nodeMap() | bitpos, dataMap() ^ bitpos, dst); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 1]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = node.getKey(0); + System.arraycopy(src, idxNew, dst, idxNew + 1, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 1, src.length - idxOld - 1); + + return nodeOf(mutator, nodeMap() ^ bitpos, dataMap() | bitpos, dst); + } + + } + + private static final class HashCollisionSetNode_5Bits extends CompactSetNode { + + private final K[] keys; + + private final int hash; + + HashCollisionSetNode_5Bits(final int hash, final K[] keys) { + this.keys = keys; + + this.hash = hash; + + assert payloadArity() >= 2; + } + + @Override + public ArrayView> nodeArray() { + return ArrayView.empty(); + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + @Override + public /* protected */ boolean contains(final K key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (K k : keys) { + if (k.equals(key)) { + return true; + } + } + } + return false; + } + + @Override + boolean contains(final K key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (K k : keys) { + if (cmp.compare(k, key) == 0) { + return true; + } + } + } + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (key.equals(_key)) { + return Optional.of(_key); + } + } + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (cmp.compare(key, _key) == 0) { + return Optional.of(_key); + } + } + return Optional.empty(); + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + @Override + public /* protected */ CompactSetNode updated(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + return this; + } + } + + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + details.modified(); + return new HashCollisionSetNode_5Bits<>(keyHash, keysNew); + } + + @Override + CompactSetNode updated(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + return this; + } + } + + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + details.modified(); + return new HashCollisionSetNode_5Bits<>(keyHash, keysNew); + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + @Override + public /* protected */ CompactSetNode removed(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + details.modified(); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + + return CompactSetNode.nodeOf(mutator).updated(mutator, theOtherKey, keyHash, 0, + details); + } else { + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + return new HashCollisionSetNode_5Bits<>(keyHash, keysNew); + } + } + } + return this; + } + + @Override + CompactSetNode removed(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + details.modified(); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + + return CompactSetNode.nodeOf(mutator).updated(mutator, theOtherKey, keyHash, 0, + details, cmp); + } else { + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + return new HashCollisionSetNode_5Bits<>(keyHash, keysNew); + } + } + } + return this; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return keys.length; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + int arity() { + return payloadArity(); + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + K getKey(final int index) { + return keys[index]; + } + + @Override + public CompactSetNode getNode(int index) { + throw new IllegalStateException("Is leaf node."); + } + +// @Override +// public void setNode(AtomicReference mutator, int index, AbstractSetNode node) { +// throw new IllegalStateException("Is leaf node."); +// } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + hash; + result = prime * result + Arrays.hashCode(keys); + return result; + } + + @Override + public boolean equals(Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + HashCollisionSetNode_5Bits that = (HashCollisionSetNode_5Bits) other; + + if (hash != that.hash) { + return false; + } + + if (arity() != that.arity()) { + return false; + } + + /* + * Linear scan for each key, because of arbitrary element order. + */ + outerLoop: + for (int i = 0; i < that.payloadArity(); i++) { + final Object otherKey = that.getKey(i); + + for (int j = 0; j < keys.length; j++) { + final K key = keys[j]; + + if (key.equals(otherKey)) { + continue outerLoop; + } + } + return false; + + } + + return true; + } + + @Override + CompactSetNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactSetNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new UnsupportedOperationException(); + } + + @Override + final int nodeMap() { + throw new UnsupportedOperationException(); + } + + @Override + final int dataMap() { + throw new UnsupportedOperationException(); + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractSetNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractSetNode[] nodes = new AbstractSetNode[MAX_DEPTH]; + + AbstractSetIterator(AbstractSetNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractSetNode nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetKeyIterator extends AbstractSetIterator implements Iterator { + + SetKeyIterator(AbstractSetNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieSet_5BitsNodeIterator implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieSet_5BitsNodeIterator(AbstractSetNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractSetNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractSetNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieSet_5Bits implements Set.Transient { + + final private AtomicReference mutator; + private AbstractSetNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieSet_5Bits(PersistentTrieSet trieSet_5Bits) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieSet_5Bits.rootNode; + this.hashCode = trieSet_5Bits.hashCode; + this.cachedSize = trieSet_5Bits.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator it = keyIterator(); it.hasNext(); ) { + final K key = it.next(); + + hash += key.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean add(final K key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean addAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean remove(final Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean removeAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean retainAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(final Object o) { + try { + final K key = (K) o; + return rootNode.contains(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + return rootNode.contains(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public K get(final Object o) { + try { + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public K getEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public boolean __insert(final K key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + + rootNode = newRootNode; + hashCode += keyHash; + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean __insertEquivalent(final K key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + + rootNode = newRootNode; + hashCode += keyHash; + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean __insertAll(final java.util.Set set) { + boolean modified = false; + + for (final K key : set) { + modified |= this.__insert(key); + } + + return modified; + } + + @Override + public boolean __insertAllEquivalent(final java.util.Set set, + final Comparator cmp) { + boolean modified = false; + + for (final K key : set) { + modified |= this.__insertEquivalent(key, cmp); + } + + return modified; + } + + @Override + public boolean __remove(final K key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + rootNode = newRootNode; + hashCode = hashCode - keyHash; + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return false; + } + + @Override + public boolean __removeEquivalent(final K key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + rootNode = newRootNode; + hashCode = hashCode - keyHash; + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return false; + } + + @Override + public boolean __removeAll(final java.util.Set set) { + boolean modified = false; + + for (final K key : set) { + modified |= this.__remove(key); + } + + return modified; + } + + @Override + public boolean __removeAllEquivalent(final java.util.Set set, + final Comparator cmp) { + boolean modified = false; + + for (final K key : set) { + modified |= this.__removeEquivalent(key, cmp); + } + + return modified; + } + + @Override + public boolean __retainAll(final java.util.Set set) { + boolean modified = false; + + Iterator thisIterator = iterator(); + while (thisIterator.hasNext()) { + if (!set.contains(thisIterator.next())) { + thisIterator.remove(); + modified = true; + } + } + + return modified; + } + + @Override + public boolean __retainAllEquivalent(final Set.Transient transientSet, + final Comparator cmp) { + boolean modified = false; + + Iterator thisIterator = iterator(); + while (thisIterator.hasNext()) { + if (!transientSet.containsEquivalent(thisIterator.next(), cmp)) { + thisIterator.remove(); + modified = true; + } + } + + return modified; + } + + @Override + public boolean containsAll(Collection c) { + for (Object item : c) { + if (!contains(item)) { + return false; + } + } + return true; + } + + @Override + public boolean containsAllEquivalent(Collection c, Comparator cmp) { + for (Object item : c) { + if (!containsEquivalent(item, cmp)) { + return false; + } + } + return true; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator iterator() { + return keyIterator(); + } + + @Override + public Iterator keyIterator() { + return new TransientSetKeyIterator<>(this); + } + + public static class TransientSetKeyIterator extends SetKeyIterator { + + final TransientTrieSet_5Bits collection; + K lastKey; + + public TransientSetKeyIterator(final TransientTrieSet_5Bits collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(lastKey); + } + } + + @Override + public Object[] toArray() { + Object[] array = new Object[cachedSize]; + + int idx = 0; + for (K key : this) { + array[idx++] = key; + } + + return array; + } + + @Override + public T[] toArray(final T[] a) { + List list = new ArrayList(cachedSize); + + for (K key : this) { + list.add(key); + } + + return list.toArray(a); + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieSet_5Bits) { + TransientTrieSet_5Bits that = (TransientTrieSet_5Bits) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof java.util.Set) { + java.util.Set that = (java.util.Set) other; + + if (this.size() != that.size()) { + return false; + } + + return containsAll(that); + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public Set.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new PersistentTrieSet(rootNode, hashCode, cachedSize); + } + } + +} diff --git a/capsule-core/src/main/java/io/usethesource/capsule/core/PersistentTrieSetMultimap.java b/capsule-core/src/main/java/io/usethesource/capsule/core/PersistentTrieSetMultimap.java new file mode 100644 index 0000000..f03850b --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/core/PersistentTrieSetMultimap.java @@ -0,0 +1,3834 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.core; + +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Deque; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import io.usethesource.capsule.SetMultimap; +import io.usethesource.capsule.core.PersistentTrieSetMultimap.EitherSingletonOrCollection.Type; +import io.usethesource.capsule.core.trie.ArrayView; +import io.usethesource.capsule.core.trie.Node; +import io.usethesource.capsule.util.EqualityComparator; +import io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap; + +import static io.usethesource.capsule.core.PersistentTrieSetMultimap.EitherSingletonOrCollection.Type.COLLECTION; +import static io.usethesource.capsule.core.PersistentTrieSetMultimap.EitherSingletonOrCollection.Type.SINGLETON; +import static io.usethesource.capsule.util.BitmapUtils.isBitInBitmap; +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +/** + * Persistent trie-based set multi-map implementing the HCHAMP encoding. + */ +public class PersistentTrieSetMultimap implements SetMultimap.Immutable { + + private final EqualityComparator cmp; + + private static final PersistentTrieSetMultimap EMPTY_SETMULTIMAP = new PersistentTrieSetMultimap( + EqualityComparator.EQUALS, CompactSetMultimapNode.EMPTY_NODE, 0, 0, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractSetMultimapNode rootNode; + private final int hashCode; + private final int cachedSize; + + private final int cachedKeySetSize; + private final int cachedKeySetHashCode; + + PersistentTrieSetMultimap(EqualityComparator cmp, AbstractSetMultimapNode rootNode, + int hashCode, int cachedSize, int keySetHashCode, int keySetSize) { + this.cmp = cmp; + this.rootNode = rootNode; + + this.hashCode = hashCode; + this.cachedSize = cachedSize; + + this.cachedKeySetHashCode = keySetHashCode; + this.cachedKeySetSize = keySetSize; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize, entryIterator()); + assert checkKeySetHashCodeAndSize(cachedKeySetHashCode, cachedKeySetSize, keyIterator()); + } + } + + public static final SetMultimap.Immutable of() { + return PersistentTrieSetMultimap.EMPTY_SETMULTIMAP; + } + + public static final SetMultimap.Immutable of(EqualityComparator cmp) { + // TODO: unify with `of()` + return new PersistentTrieSetMultimap(cmp, CompactSetMultimapNode.EMPTY_NODE, 0, 0, 0, 0); + } + + public static final SetMultimap.Immutable of(K key, V... values) { + SetMultimap.Immutable result = PersistentTrieSetMultimap.EMPTY_SETMULTIMAP; + + for (V value : values) { + result = result.__insert(key, value); + } + + return result; + } + + public static final SetMultimap.Immutable of(K key0, V value0, K key1, V value1) { + SetMultimap.Transient result = PersistentTrieSetMultimap.EMPTY_SETMULTIMAP.asTransient(); + result.__insert(key0, value0); + result.__insert(key1, value1); + return result.freeze(); + } + + public static final SetMultimap.Transient transientOf() { + return PersistentTrieSetMultimap.EMPTY_SETMULTIMAP.asTransient(); + } + + public static final SetMultimap.Transient transientOf( + EqualityComparator cmp) { + // TODO: unify with `of()` + return (SetMultimap.Transient) of(cmp).asTransient(); + } + + public static final SetMultimap.Transient transientOf(K key, V... values) { + final SetMultimap.Transient result = + PersistentTrieSetMultimap.EMPTY_SETMULTIMAP.asTransient(); + + for (V value : values) { + result.__insert(key, value); + } + + return result; + } + + static boolean checkHashCodeAndSize(final int targetHash, final int targetSize, + final Iterator> iterator) { + int hash = 0; + int size = 0; + + while (iterator.hasNext()) { + final Map.Entry entry = iterator.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + static boolean checkKeySetHashCodeAndSize(final int targetHash, final int targetSize, + final Iterator iterator) { + int hash = 0; + int size = 0; + + while (iterator.hasNext()) { + final K key = iterator.next(); + + hash += key.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.equals(iterator.next(), o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + return rootNode.containsTuple(key, val, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public SetMultimap.Immutable __put(K key, V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = val.hashCode(); + + return new PersistentTrieSetMultimap(cmp, newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize, + cachedKeySetHashCode, cachedKeySetSize); + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + final int valHashNew = val.hashCode(); + + return new PersistentTrieSetMultimap(cmp, newRootNode, + hashCode + ((keyHash ^ valHashNew)) - sumOfReplacedHashes, + cachedSize - details.getReplacedCollection().size() + 1, cachedKeySetHashCode, + cachedKeySetSize); + } + } + + // TODO: support observability of what kind of modification was done internally + final int newKeySetHashCode; + final int newKeySetSize; + if (containsKey(key)) { + newKeySetHashCode = cachedKeySetHashCode; + newKeySetSize = cachedKeySetSize; + } else { + newKeySetHashCode = cachedKeySetHashCode + keyHash; + newKeySetSize = cachedKeySetSize + 1; + } + + final int valHash = val.hashCode(); + return new PersistentTrieSetMultimap(cmp, newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1, newKeySetHashCode, newKeySetSize); + } + + return this; + } + + @Override + public SetMultimap.Immutable __insert(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + // TODO: support observability of what kind of modification was done internally + final int newKeySetHashCode; + final int newKeySetSize; + if (containsKey(key)) { + newKeySetHashCode = cachedKeySetHashCode; + newKeySetSize = cachedKeySetSize; + } else { + newKeySetHashCode = cachedKeySetHashCode + keyHash; + newKeySetSize = cachedKeySetSize + 1; + } + + final int valHash = val.hashCode(); + return new PersistentTrieSetMultimap(cmp, newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1, newKeySetHashCode, newKeySetSize); + } + + return this; + } + + @Override + public SetMultimap.Immutable union( + final SetMultimap setMultimap) { + final SetMultimap.Transient tmpTransient = this.asTransient(); + tmpTransient.union(setMultimap); + return tmpTransient.freeze(); + } + + @Override + public SetMultimap.Immutable __remove(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + + // TODO: support observability of what kind of modification was done internally + final int newKeySetHashCode; + final int newKeySetSize; + if (newRootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp)) { + newKeySetHashCode = cachedKeySetHashCode; + newKeySetSize = cachedKeySetSize; + } else { + newKeySetHashCode = cachedKeySetHashCode - keyHash; + newKeySetSize = cachedKeySetSize - 1; + } + + final int valHash = details.getReplacedValue().hashCode(); + return new PersistentTrieSetMultimap(cmp, newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1, newKeySetHashCode, newKeySetSize); + } + + return this; + } + + @Override + public SetMultimap.Immutable __remove(K key) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removedAll(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHash = details.getReplacedValue().hashCode(); + return new PersistentTrieSetMultimap(cmp, newRootNode, + hashCode - ((keyHash ^ valHash)), + cachedSize - 1, cachedKeySetHashCode - keyHash, cachedKeySetSize - 1); + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + return new PersistentTrieSetMultimap(cmp, newRootNode, hashCode - sumOfReplacedHashes, + cachedSize - details.getReplacedCollection().size(), cachedKeySetHashCode - keyHash, + cachedKeySetSize - 1); + } + } + + return this; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public int sizeDistinct() { + return cachedKeySetSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new SetMultimapKeyIterator<>(rootNode); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(Set::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + return new SetMultimapTupleIterator<>(rootNode, AbstractSpecialisedImmutableMap::entryOf); + } + + @Override + public Iterator> nativeEntryIterator() { + return new SetMultimapNativeTupleIterator<>(rootNode); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new SetMultimapTupleIterator<>(rootNode, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return PersistentTrieSetMultimap.this.keyIterator(); + } + + @Override + public int size() { + return PersistentTrieSetMultimap.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return PersistentTrieSetMultimap.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return PersistentTrieSetMultimap.this.containsKey(k); + } + }; + } + + return keySet; + } + +// /** +// * Eagerly calcualated set of keys (instead of returning a set view on a map). +// * +// * @return canonical SetMultimap.Immutable set of keys +// */ +// @Override +// public Set keySet() { +// final BottomUpTransientNodeTransformer, PersistentTrieSet.AbstractSetNode> transformer = +// new BottomUpTransientNodeTransformer<>(rootNode, +// (node, mutator) -> node.toSetNode(mutator)); +// +// final PersistentTrieSet.AbstractSetNode newRootNode = transformer.apply(); +// +// return new PersistentTrieSet<>(newRootNode, cachedKeySetHashCode, cachedKeySetSize); +// } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return PersistentTrieSetMultimap.this.valueIterator(); + } + + @Override + public int size() { + return PersistentTrieSetMultimap.this.size(); + } + + @Override + public boolean isEmpty() { + return PersistentTrieSetMultimap.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return PersistentTrieSetMultimap.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return PersistentTrieSetMultimap.this.size(); + } + + @Override + public boolean isEmpty() { + return PersistentTrieSetMultimap.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return PersistentTrieSetMultimap.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof PersistentTrieSetMultimap) { + PersistentTrieSetMultimap that = (PersistentTrieSetMultimap) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + final io.usethesource.capsule.Set.Immutable valColl = + (io.usethesource.capsule.Set.Immutable) entry.getValue(); + + if (!cmp.equals(result.get(), valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public String toString() { + String body = + entrySet().stream().map(entry -> String.format("%s: %s", entry.getKey(), entry.getValue())) + .reduce((o1, o2) -> String.join(", ", o1, o2)).orElse(""); + return String.format("{%s}", body); + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public SetMultimap.Transient asTransient() { + return new TransientTrieSetMultimap_BleedingEdge(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractSetMultimapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieSetMultimap_BleedingEdgeNodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + static abstract class EitherSingletonOrCollection { + + public enum Type { + SINGLETON, COLLECTION + } + + public static final EitherSingletonOrCollection of(T value) { + return new SomeSingleton<>(value); + } + + public static final EitherSingletonOrCollection of( + io.usethesource.capsule.Set.Immutable value) { + return new SomeCollection<>(value); + } + + abstract boolean isType(Type type); + + abstract T getSingleton(); + + abstract io.usethesource.capsule.Set.Immutable getCollection(); + } + + static final class SomeSingleton extends EitherSingletonOrCollection { + + private final T value; + + private SomeSingleton(T value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.SINGLETON; + } + + @Override + T getSingleton() { + return value; + } + + @Override + io.usethesource.capsule.Set.Immutable getCollection() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.COLLECTION, Type.SINGLETON)); + } + } + + static final class SomeCollection extends EitherSingletonOrCollection { + + private final io.usethesource.capsule.Set.Immutable value; + + private SomeCollection(io.usethesource.capsule.Set.Immutable value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.COLLECTION; + } + + @Override + T getSingleton() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.SINGLETON, Type.COLLECTION)); + } + + @Override + io.usethesource.capsule.Set.Immutable getCollection() { + return value; + } + } + + static final class SetMultimapResult { + + private V replacedValue; + private io.usethesource.capsule.Set.Immutable replacedValueCollection; + private EitherSingletonOrCollection.Type replacedType; + + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(V replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + this.replacedType = SINGLETON; + } + + public void updated( + io.usethesource.capsule.Set.Immutable replacedValueCollection) { + this.replacedValueCollection = replacedValueCollection; + this.isModified = true; + this.isReplaced = true; + this.replacedType = COLLECTION; + } + + // update: neither element, nor element count changed + public static SetMultimapResult unchanged() { + return new SetMultimapResult<>(); + } + + private SetMultimapResult() { + } + + public boolean isModified() { + return isModified; + } + + public EitherSingletonOrCollection.Type getType() { + return replacedType; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public V getReplacedValue() { + assert getType() == SINGLETON; + return replacedValue; + } + + public io.usethesource.capsule.Set.Immutable getReplacedCollection() { + assert getType() == COLLECTION; + return replacedValueCollection; + } + } + + protected static abstract class AbstractSetMultimapNode implements Node { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract boolean containsTuple(final K key, final V val, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract Optional> findByKey( + final K key, final int keyHash, final int shift, EqualityComparator cmp); + + abstract CompactSetMultimapNode inserted(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode updated(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode removed(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode removedAll(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + @Override + public abstract ArrayView> nodeArray(); + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractSetMultimapNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractSetMultimapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractSetMultimapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(EitherSingletonOrCollection.Type type); + + abstract int payloadArity(EitherSingletonOrCollection.Type type); + + abstract K getSingletonKey(final int index); + + abstract V getSingletonValue(final int index); + + abstract K getCollectionKey(final int index); + + abstract io.usethesource.capsule.Set.Immutable getCollectionValue( + final int index); + + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + abstract int arity(); + + int size() { + final Iterator it = new SetMultimapKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + + /***** CONVERISONS *****/ + + abstract PersistentTrieSet.AbstractSetNode toSetNode(AtomicReference mutator); + + // abstract PersistentTrieSet.AbstractSetNode toSetNode( + // PersistentTrieSet.AbstractSetNode... newChildren); + + // PersistentTrieSet.AbstractSetNode toSetNode() { + // throw new UnsupportedOperationException( + // "Not yet implemented ~ structural conversion of multimap to set."); + // } + } + + protected static abstract class CompactSetMultimapNode + extends AbstractSetMultimapNode { + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + abstract int bitmap(int category); + + @Deprecated + abstract int dataMap(); + + @Deprecated + abstract int collMap(); + + @Deprecated + abstract int nodeMap(); + + abstract int rawMap1(); + + abstract int rawMap2(); + + @Deprecated + @Override + int arity() { + return arity(dataMap()) + arity(collMap()) + arity(nodeMap()); + } + + static final int arity(int bitmap) { + if (bitmap == 0) { + return 0; + } else { + return Integer.bitCount(bitmap); + } + } + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactSetMultimapNode getNode(final int index); + + boolean nodeInvariant() { + return true; + // boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + // boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + // boolean inv3 = + // (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + // boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + // + // boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + // && ((this.payloadArity() + this.nodeArity()) == this.arity()); + // + // return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + final int rawMap1, final int rawMap2); + + abstract CompactSetMultimapNode copyAndSetSingletonValue( + final AtomicReference mutator, final int bitpos, final V val); + + abstract CompactSetMultimapNode copyAndSetCollectionValue( + final AtomicReference mutator, final int bitpos, + final io.usethesource.capsule.Set.Immutable valColl); + + abstract CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final int bitpos, final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndInsertSingleton( + final AtomicReference mutator, final int bitpos, final K key, final V val); + + abstract CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + final AtomicReference mutator, final int bitpos, final K key, + final io.usethesource.capsule.Set.Immutable valColl); + + abstract CompactSetMultimapNode copyAndRemoveSingleton( + final AtomicReference mutator, final int bitpos); + + /* + * Batch updated, necessary for removedAll. + */ + abstract CompactSetMultimapNode copyAndRemoveCollection( + final AtomicReference mutator, final int bitpos); + + abstract CompactSetMultimapNode copyAndMigrateFromSingletonToNode( + final AtomicReference mutator, final int bitpos, + final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndMigrateFromNodeToSingleton( + final AtomicReference mutator, final int bitpos, + final CompactSetMultimapNode node); // node get's unwrapped inside method + + abstract CompactSetMultimapNode copyAndMigrateFromCollectionToNode( + final AtomicReference mutator, final int bitpos, + final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndMigrateFromNodeToCollection( + final AtomicReference mutator, final int bitpos, + final CompactSetMultimapNode node); // node get's unwrapped inside method + + abstract CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + final AtomicReference mutator, final int bitpos, final K key, final V val); + + static final CompactSetMultimapNode mergeTwoSingletonPairs(final K key0, + final V val0, final int keyHash0, final K key1, final V val1, final int keyHash1, + final int shift, EqualityComparator cmp) { + // assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode + .of(keyHash0, key0, io.usethesource.capsule.Set.Immutable.of(val0), key1, + io.usethesource.capsule.Set.Immutable.of(val1)); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int rawMap1 = 0; + final int rawMap2 = bitpos(mask0) | bitpos(mask1); + + if (mask0 < mask1) { + return nodeOf(null, rawMap1, rawMap2, new Object[]{key0, val0, key1, val1}); + } else { + return nodeOf(null, rawMap1, rawMap2, new Object[]{key1, val1, key0, val0}); + } + } else { + final CompactSetMultimapNode node = mergeTwoSingletonPairs(key0, val0, keyHash0, key1, + val1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + + final int rawMap1 = bitpos(mask0); + final int rawMap2 = 0; + return nodeOf(null, rawMap1, rawMap2, new Object[]{node}); + } + } + + static final CompactSetMultimapNode mergeCollectionAndSingletonPairs(final K key0, + final io.usethesource.capsule.Set.Immutable valColl0, final int keyHash0, + final K key1, final V val1, final int keyHash1, final int shift, + EqualityComparator cmp) { + // assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode + .of(keyHash0, key1, io.usethesource.capsule.Set.Immutable.of(val1), key0, valColl0); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int rawMap1 = bitpos(mask0); + final int rawMap2 = bitpos(mask0) | bitpos(mask1); + + // singleton before collection + return nodeOf(null, rawMap1, rawMap2, new Object[]{key1, val1, key0, valColl0}); + } else { + final CompactSetMultimapNode node = mergeCollectionAndSingletonPairs(key0, valColl0, + keyHash0, key1, val1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + + final int rawMap1 = bitpos(mask0); + final int rawMap2 = 0; + return nodeOf(null, rawMap1, rawMap2, new Object[]{node}); + } + } + + static final CompactSetMultimapNode EMPTY_NODE; + + static { + EMPTY_NODE = new BitmapIndexedSetMultimapNode<>(null, (0), (0), new Object[]{}); + } + + ; + + static final CompactSetMultimapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object[] nodes) { + return new BitmapIndexedSetMultimapNode<>(mutator, nodeMap, dataMap, nodes); + } + + static final CompactSetMultimapNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactSetMultimapNode nodeOf(AtomicReference mutator, + final int nodeMap, final int dataMap, final K key, + final io.usethesource.capsule.Set.Immutable valColl) { + assert nodeMap == 0; + return nodeOf(mutator, (0), dataMap, new Object[]{key, valColl}); + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + @Deprecated + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + @Deprecated + int collIndex(final int bitpos) { + return java.lang.Integer.bitCount(collMap() & (bitpos - 1)); + } + + @Deprecated + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + int rawMap1 = this.rawMap1(); + int rawMap2 = this.rawMap2(); + + final int collMap = rawMap1 & rawMap2; + final int dataMap = rawMap2 ^ collMap; + final int nodeMap = rawMap1 ^ collMap; + + if (isBitInBitmap(dataMap, bitpos)) { + final int index = index(dataMap, mask, bitpos); + return cmp.equals(getSingletonKey(index), key); + } + + if (isBitInBitmap(collMap, bitpos)) { + final int index = index(collMap, mask, bitpos); + return cmp.equals(getCollectionKey(index), key); + } + + if (isBitInBitmap(nodeMap, bitpos)) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return false; + } + + @Override + boolean containsTuple(final K key, final V val, final int keyHash, final int shift, + EqualityComparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + int rawMap1 = this.rawMap1(); + int rawMap2 = this.rawMap2(); + + final int collMap = rawMap1 & rawMap2; + final int dataMap = rawMap2 ^ collMap; + final int nodeMap = rawMap1 ^ collMap; + + if (isBitInBitmap(dataMap, bitpos)) { + final int index = index(dataMap, mask, bitpos); + return cmp.equals(getSingletonKey(index), key) && cmp.equals(getSingletonValue(index), val); + } + + if (isBitInBitmap(collMap, bitpos)) { + final int index = index(collMap, mask, bitpos); + return cmp.equals(getCollectionKey(index), key) + && getCollectionValue(index).containsEquivalent(val, cmp.toComparator()); + } + + if (isBitInBitmap(nodeMap, bitpos)) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsTuple(key, val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return false; + } + + @Override + Optional> findByKey(final K key, + final int keyHash, final int shift, EqualityComparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + int rawMap1 = this.rawMap1(); + int rawMap2 = this.rawMap2(); + + final int collMap = rawMap1 & rawMap2; + final int dataMap = rawMap2 ^ collMap; + final int nodeMap = rawMap1 ^ collMap; + + if (isBitInBitmap(dataMap, bitpos)) { + final int index = index(dataMap, mask, bitpos); + + final K currentKey = getSingletonKey(index); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(index); + return Optional.of(io.usethesource.capsule.Set.Immutable.of(currentVal)); + } + + return Optional.empty(); + } + + if (isBitInBitmap(collMap, bitpos)) { + final int index = index(collMap, mask, bitpos); + + final K currentKey = getCollectionKey(index); + if (cmp.equals(currentKey, key)) { + + final io.usethesource.capsule.Set.Immutable currentValColl = + getCollectionValue(index); + return Optional.of(currentValColl); + } + + return Optional.empty(); + } + + if (isBitInBitmap(nodeMap, bitpos)) { + final int index = index(nodeMap, mask, bitpos); + + final AbstractSetMultimapNode subNode = getNode(index); + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + // default + return Optional.empty(); + } + + @Override + CompactSetMultimapNode inserted(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + int rawMap1 = this.rawMap1(); + int rawMap2 = this.rawMap2(); + + final int collMap = rawMap1 & rawMap2; + final int dataMap = rawMap2 ^ collMap; + final int nodeMap = rawMap1 ^ collMap; + + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + if (cmp.equals(currentVal, val)) { + return this; + } else { + // migrate from singleton to collection + final io.usethesource.capsule.Set.Immutable valColl = + io.usethesource.capsule.Set.Immutable.of(currentVal, val); + + details.modified(); + return copyAndMigrateFromSingletonToCollection(mutator, bitpos, currentKey, valColl); + } + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, bitpos, subNodeNew); + } + } + + if (isBitInBitmap(collMap, bitpos)) { + final int collIndex = index(collMap, mask, bitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final io.usethesource.capsule.Set.Immutable currentCollVal = + getCollectionValue(collIndex); + + if (currentCollVal.contains(val)) { + return this; + } else { + // add new mapping + final io.usethesource.capsule.Set.Immutable newCollVal = + currentCollVal.__insert(val); + + details.modified(); + return copyAndSetCollectionValue(mutator, bitpos, newCollVal); + } + } else { + // prefix-collision (case: collection x singleton) + final io.usethesource.capsule.Set.Immutable currentValNode = + getCollectionValue(collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, bitpos, subNodeNew); + } + } + + if (isBitInBitmap(nodeMap, bitpos)) { + final CompactSetMultimapNode subNode = getNode(nodeIndex(bitpos)); + final CompactSetMultimapNode subNodeNew = + subNode.inserted(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } + + // default + details.modified(); + return copyAndInsertSingleton(mutator, bitpos, key, val); + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + int rawMap1 = this.rawMap1(); + int rawMap2 = this.rawMap2(); + + final int collMap = rawMap1 & rawMap2; + final int dataMap = rawMap2 ^ collMap; + final int nodeMap = rawMap1 ^ collMap; + + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + // update singleton value + details.updated(currentVal); + return copyAndSetSingletonValue(mutator, bitpos, val); + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, bitpos, subNodeNew); + } + } + + if (isBitInBitmap(collMap, bitpos)) { + final int collIndex = index(collMap, mask, bitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final io.usethesource.capsule.Set.Immutable currentCollVal = + getCollectionValue(collIndex); + + // migrate from collection to singleton + details.updated(currentCollVal); + return copyAndMigrateFromCollectionToSingleton(mutator, bitpos, currentCollKey, val); + } else { + // prefix-collision (case: collection x singleton) + final io.usethesource.capsule.Set.Immutable currentValNode = + getCollectionValue(collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, bitpos, subNodeNew); + } + } + + if (isBitInBitmap(nodeMap, bitpos)) { + final CompactSetMultimapNode subNode = getNode(nodeIndex(bitpos)); + final CompactSetMultimapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } + + // default + details.modified(); + return copyAndInsertSingleton(mutator, bitpos, key, val); + } + + @Override + CompactSetMultimapNode removed(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + int rawMap1 = this.rawMap1(); + int rawMap2 = this.rawMap2(); + + final int collMap = rawMap1 & rawMap2; + final int dataMap = rawMap2 ^ collMap; + final int nodeMap = rawMap1 ^ collMap; + + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(dataIndex); + if (cmp.equals(currentVal, val)) { + + // remove mapping + details.updated(val); + return copyAndRemoveSingleton(mutator, bitpos).canonicalize(mutator, keyHash, shift); + + } else { + return this; + } + } else { + return this; + } + } + + if (isBitInBitmap(collMap, bitpos)) { + final int collIndex = index(collMap, mask, bitpos); + + final K currentKey = getCollectionKey(collIndex); + if (cmp.equals(currentKey, key)) { + + final io.usethesource.capsule.Set.Immutable currentValColl = + getCollectionValue(collIndex); + if (currentValColl.contains(val)) { + + // remove mapping + details.updated(val); + + final io.usethesource.capsule.Set.Immutable newValColl = + currentValColl.__remove(val); + + if (newValColl.size() == 1) { + // TODO: investigate options for unboxing singleton collections + V remainingVal = newValColl.iterator().next(); + return copyAndMigrateFromCollectionToSingleton(mutator, bitpos, key, remainingVal); + } else { + return copyAndSetCollectionValue(mutator, bitpos, newValColl); + } + } else { + return this; + } + } else { + return this; + } + } + + if (isBitInBitmap(nodeMap, bitpos)) { + final CompactSetMultimapNode subNode = getNode(index(nodeMap, mask, bitpos)); + final CompactSetMultimapNode subNodeNew = + subNode.removed(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (arity(nodeMap) == 1 && arity(dataMap) == 0 && arity(collMap) == 0) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, bitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, bitpos, subNodeNew); + } + + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + // default + return this; + } + + @Override + CompactSetMultimapNode removedAll(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + int rawMap1 = this.rawMap1(); + int rawMap2 = this.rawMap2(); + + final int collMap = rawMap1 & rawMap2; + final int dataMap = rawMap2 ^ collMap; + final int nodeMap = rawMap1 ^ collMap; + + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(dataIndex); + // if (cmp.equals(currentVal, val)) { + // + // // remove mapping + // details.updated(val); + // return copyAndRemoveSingleton(mutator, bitpos).canonicalize(mutator, keyHash, shift); + // + // } else { + // return this; + // } + details.updated(currentVal); + return copyAndRemoveSingleton(mutator, bitpos).canonicalize(mutator, keyHash, shift); + } else { + return this; + } + } + + if (isBitInBitmap(collMap, bitpos)) { + final int collIndex = index(collMap, mask, bitpos); + + final K currentKey = getCollectionKey(collIndex); + if (cmp.equals(currentKey, key)) { + + final io.usethesource.capsule.Set.Immutable currentValColl = + getCollectionValue(collIndex); + // if (currentValColl.contains(val)) { + // + // // remove mapping + // details.updated(val); + // + // final Immutable newValColl = currentValColl.__remove(val); + // + // if (newValColl.size() == 1) { + // // TODO: investigate options for unboxing singleton collections + // V remainingVal = newValColl.iterator().next(); + // return copyAndMigrateFromCollectionToSingleton(mutator, bitpos, key, remainingVal); + // } else { + // return copyAndSetCollectionValue(mutator, bitpos, newValColl); + // } + // } else { + // return this; + // } + details.updated(currentValColl); + return copyAndRemoveCollection(mutator, bitpos).canonicalize(mutator, keyHash, shift); + } else { + return this; + } + } + + if (isBitInBitmap(nodeMap, bitpos)) { + final CompactSetMultimapNode subNode = getNode(index(nodeMap, mask, bitpos)); + final CompactSetMultimapNode subNodeNew = + subNode.removedAll(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (arity(nodeMap) == 1 && arity(dataMap) == 0 && arity(collMap) == 0) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, bitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, bitpos, subNodeNew); + } + + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + // default + return this; + } + + abstract EitherSingletonOrCollection.Type typeOfSingleton(); + + abstract CompactSetMultimapNode canonicalize(AtomicReference mutator, + final int keyHash, final int shift); + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + int rawMap1 = this.rawMap1(); + int rawMap2 = this.rawMap2(); + + final int collMap = rawMap1 & rawMap2; + final int dataMap = rawMap2 ^ collMap; + final int nodeMap = rawMap1 ^ collMap; + + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < arity(dataMap); i++) { + final byte pos = recoverMask(dataMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getSingletonKey(i)), + Objects.hashCode(getSingletonValue(i)))); + + if (!((i + 1) == arity(dataMap))) { + bldr.append(", "); + } + } + + if (arity(dataMap) > 0 && arity(collMap) > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arity(collMap); i++) { + final byte pos = recoverMask(collMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getCollectionKey(i)), + Objects.hashCode(getCollectionValue(i)))); + + if (!((i + 1) == arity(collMap))) { + bldr.append(", "); + } + } + + if (arity(collMap) > 0 && arity(nodeMap) > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arity(nodeMap); i++) { + final byte pos = recoverMask(nodeMap, (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == arity(nodeMap))) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedSetMultimapNode + extends CompactSetMultimapNode { + + private final int rawMap1; // former nodeMap + private final int rawMap2; // former dataMap + + CompactMixedSetMultimapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.rawMap1 = nodeMap; + this.rawMap2 = dataMap; + } + + @Override + public int rawMap1() { // former nodeMap + return rawMap1; + } + + @Override + public int rawMap2() { // former dataMap + return rawMap2; + } + + @Override + final int bitmap(int category) { + switch (category) { + case 0: + return dataMap(); + case 1: + return collMap(); + default: + return 0; + } + } + + @Override + final int dataMap() { + return rawMap2() ^ collMap(); + } + + @Override + final int collMap() { + return rawMap1() & rawMap2(); + } + + @Override + final int nodeMap() { + return rawMap1() ^ collMap(); + } + + } + + private static final class BitmapIndexedSetMultimapNode + extends CompactMixedSetMultimapNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedSetMultimapNode(final AtomicReference mutator, final int rawMap1, + final int rawMap2, final Object[] nodes) { + super(mutator, rawMap1, rawMap2); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + final int collMap = rawMap1 & rawMap2; + final int dataMap = rawMap2 ^ collMap; + final int nodeMap = rawMap1 ^ collMap; + + assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + + TUPLE_LENGTH * java.lang.Integer.bitCount(collMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < arity(dataMap); i++) { + int offset = i * TUPLE_LENGTH; + + assert ((nodes[offset + + 0] instanceof io.usethesource.capsule.Set.Immutable) == false); + assert ((nodes[offset + + 1] instanceof io.usethesource.capsule.Set.Immutable) == false); + + assert ((nodes[offset + 0] instanceof CompactSetMultimapNode) == false); + assert ((nodes[offset + 1] instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arity(collMap); i++) { + int offset = (i + arity(dataMap)) * TUPLE_LENGTH; + + assert ((nodes[offset + + 0] instanceof io.usethesource.capsule.Set.Immutable) == false); + assert ((nodes[offset + + 1] instanceof io.usethesource.capsule.Set.Immutable) == true); + + assert ((nodes[offset + 0] instanceof CompactSetMultimapNode) == false); + assert ((nodes[offset + 1] instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arity(nodeMap); i++) { + int offset = (arity(dataMap) + arity(collMap)) * TUPLE_LENGTH; + + assert ((nodes[offset + + i] instanceof io.usethesource.capsule.Set.Immutable) == false); + + assert ((nodes[offset + i] instanceof CompactSetMultimapNode) == true); + } + } + + assert nodeInvariant(); + } + + @Override + public ArrayView dataArray(final int category, final int component) { + switch (category) { + case 0: + return categoryArrayView0(component); + case 1: + return categoryArrayView1(component); + default: + throw new IllegalArgumentException("Category %i is not supported."); + } + } + + private ArrayView categoryArrayView0(final int component) { + return new ArrayView() { + @Override + public int size() { + return arity(dataMap()); + } + + @Override + public T get(int index) { + switch (component) { + case 0: + return (T) getSingletonKey(index); + case 1: + return (T) getSingletonValue(index); + } + throw new IllegalStateException(); + } + }; + } + + private ArrayView categoryArrayView1(final int component) { + return new ArrayView() { + @Override + public int size() { + return arity(collMap()); + } + + @Override + public T get(int index) { + switch (component) { + case 0: + return (T) getCollectionKey(index); + case 1: + return (T) getCollectionValue(index); + } + throw new IllegalStateException(); + } + }; + } + + @Override + public ArrayView> nodeArray() { + return new ArrayView>() { + @Override + public int size() { + return BitmapIndexedSetMultimapNode.this.nodeArity(); + } + + @Override + public AbstractSetMultimapNode get(int index) { + return (AbstractSetMultimapNode) BitmapIndexedSetMultimapNode.this.getNode(index); + } + + @Override + public void set(int index, AbstractSetMultimapNode item, + AtomicReference writeCapabilityToken) { + if (!isAllowedToEdit(BitmapIndexedSetMultimapNode.this.mutator, writeCapabilityToken)) { + throw new IllegalStateException(); + } + + nodes[nodes.length - 1 - index] = item; + } + }; + } + + @Override + K getSingletonKey(final int index) { + return (K) nodes[TUPLE_LENGTH * index]; + } + + @Override + V getSingletonValue(int index) { + return (V) nodes[TUPLE_LENGTH * index + 1]; + } + + @Override + K getCollectionKey(int index) { + // TODO: improve on offset calculation (caching it, etc) + int offset = TUPLE_LENGTH * (arity(dataMap()) + index); + return (K) nodes[offset]; + } + + @Override + io.usethesource.capsule.Set.Immutable getCollectionValue(final int index) { + // TODO: improve on offset calculation (caching it, etc) + int offset = TUPLE_LENGTH * (arity(dataMap()) + index) + 1; + return (io.usethesource.capsule.Set.Immutable) nodes[offset]; + } + + @Override + CompactSetMultimapNode getNode(final int index) { + return (CompactSetMultimapNode) nodes[nodes.length - 1 - index]; + } + + // @Override + // boolean hasPayload() { + // return rawMap2() != 0; + // } + // + // @Override + // int payloadArity() { + // return java.lang.Integer.bitCount(rawMap2()); + // } + + @Override + boolean hasPayload(EitherSingletonOrCollection.Type type) { + return payloadArity(type) != 0; + } + + @Override + int payloadArity(EitherSingletonOrCollection.Type type) { + if (type == Type.SINGLETON) { + return java.lang.Integer.bitCount(dataMap()); + } else { + return java.lang.Integer.bitCount(collMap()); + } + } + + @Override + boolean hasNodes() { + return nodeArity() != 0; + } + + @Override + int nodeArity() { + return java.lang.Integer.bitCount(nodeMap()); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + PersistentTrieSet.AbstractSetNode toSetNode(final AtomicReference mutator) { + final int mergedPayloadMap = rawMap2(); + + final ArrayView dataArray0 = dataArray(0, 0); + final ArrayView dataArray1 = dataArray(1, 0); + + final Iterator iterator = ziperator(arity(mergedPayloadMap), bitmap(0), + dataArray0.iterator(), bitmap(1), dataArray1.iterator()); + + // allocate an array that can hold the keys + empty placeholder slots for sub-nodes + final Object[] content = new Object[arity(mergedPayloadMap) + arity(nodeMap())]; + + for (int i = 0; iterator.hasNext(); i++) { + content[i] = iterator.next(); + } + + return PersistentTrieSet.AbstractSetNode.newBitmapIndexedNode(mutator, nodeMap(), + mergedPayloadMap, content); + } + + private Iterator ziperator(final int expectedSize, final int bitmap0, + final Iterator dataIterator0, final int bitmap1, final Iterator dataIterator1) { + return new Iterator() { + + private int encounteredSize = 0; + private int bitsToSkip = 0; + + @Override + public boolean hasNext() { + return encounteredSize < expectedSize; + } + + @Override + public T next() { + // assume that operation succeeds + encounteredSize += 1; + + int trailingZeroCount0 = Integer.numberOfTrailingZeros(bitmap0 >> bitsToSkip); + int trailingZeroCount1 = Integer.numberOfTrailingZeros(bitmap1 >> bitsToSkip); + + bitsToSkip = bitsToSkip + 1 + Math.min(trailingZeroCount0, trailingZeroCount1); + + if (trailingZeroCount0 < trailingZeroCount1) { + return dataIterator0.next(); + } else { + return dataIterator1.next(); + } + } + }; + } + + // @Override + // PersistentTrieSet.AbstractSetNode toSetNode(final AtomicReference mutator) { + // final int mergedPayloadMap = rawMap2(); + // + // // allocate an array that can hold the keys + empty placeholder slots for sub-nodes + // final Object[] setContent = new Object[arity(mergedPayloadMap) + arity(nodeMap())]; + // int index = 0; + // + // int offset1 = 0; + // int slidingMap1 = dataMap(); + // + // int offset2 = TUPLE_LENGTH * arity(dataMap()); + // int slidingMap2 = collMap(); + // + // for (int i = 0; i < 32; i++) { + // if ((slidingMap1 & 0x01) != 0) { + // setContent[index] = nodes[offset1]; + // offset1 += TUPLE_LENGTH; + // index++; + // } else if ((slidingMap2 & 0x01) != 0) { + // setContent[index] = nodes[offset2]; + // offset2 += TUPLE_LENGTH; + // index++; + // } + // + // slidingMap1 = slidingMap1 >> 1; + // slidingMap2 = slidingMap2 >> 1; + // } + // + // return PersistentTrieSet.AbstractSetNode.newBitmapIndexedNode(mutator, nodeMap(), + // mergedPayloadMap, setContent); + // } + + // @Override + // PersistentTrieSet.AbstractSetNode toSetNode(PersistentTrieSet.AbstractSetNode[] newChildren) { + // final K[] keys = (K[]) new Object[arity(rawMap2())]; + // + // int dataMap = dataMap(); + // int collMap = collMap(); + // + // int collIndex = 0; + // int dataIndex = 0; + // + // int keysIndex = 0; + // + // for (int i = 0; i < 32; i++) { + // if ((dataMap & 0x01) == 0x01) { + // keys[keysIndex] = getSingletonKey(dataIndex++); + // keysIndex++; + // } else if ((collMap & 0x01) == 0x01) { + // keys[keysIndex] = getCollectionKey(collIndex++); + // keysIndex++; + // } + // + // dataMap = dataMap >> 1; + // collMap = collMap >> 1; + // } + // + // return PersistentTrieSet.AbstractSetNode.newBitmapIndexedNode(null, nodeMap(), rawMap2(), keys, + // newChildren); + // } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + (rawMap1()); + result = prime * result + (rawMap2()); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedSetMultimapNode that = (BitmapIndexedSetMultimapNode) other; + if (rawMap1() != that.rawMap1()) { + return false; + } + if (rawMap2() != that.rawMap2()) { + return false; + } + if (!Arrays.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + if (this.nodeArity() == 0) { + switch (arity(dataMap()) + arity(collMap())) { + case 0: + return SIZE_EMPTY; + case 1: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } else { + return SIZE_MORE_THAN_ONE; + } + } + + @Override + CompactSetMultimapNode copyAndSetSingletonValue(final AtomicReference mutator, + final int bitpos, final V val) { + + final int idx = TUPLE_LENGTH * dataIndex(bitpos) + 1; + final CompactSetMultimapNode updatedNode = copyAndSetXxxValue(mutator, idx, val); + + return updatedNode; + } + + @Override + CompactSetMultimapNode copyAndSetCollectionValue(final AtomicReference mutator, + final int bitpos, final io.usethesource.capsule.Set.Immutable valColl) { + + final int idx = TUPLE_LENGTH * (arity(dataMap()) + collIndex(bitpos)) + 1; + final CompactSetMultimapNode updatedNode = copyAndSetXxxValue(mutator, idx, valColl); + + return updatedNode; + } + + private CompactSetMultimapNode copyAndSetXxxValue(final AtomicReference mutator, + final int idx, final Object newValue) { + final CompactSetMultimapNode updatedNode; + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = newValue; + updatedNode = this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = newValue; + + updatedNode = nodeOf(mutator, rawMap1(), rawMap2(), dst); + } + return updatedNode; + } + + @Override + CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final int bitpos, final CompactSetMultimapNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(bitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, rawMap1(), rawMap2(), dst); + } + } + + @Override + CompactSetMultimapNode copyAndInsertSingleton(final AtomicReference mutator, + final int bitpos, final K key, final V val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = val; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + return nodeOf(mutator, rawMap1(), rawMap2() | bitpos, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + AtomicReference mutator, int bitpos, K key, + io.usethesource.capsule.Set.Immutable valColl) { + + final int idxOld = TUPLE_LENGTH * index(dataMap(), bitpos); + final int idxNew = TUPLE_LENGTH * (arity(dataMap()) - 1 + index(collMap(), bitpos)); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = key; + dst[idxNew + 1] = valColl; + System.arraycopy(src, idxNew + 2, dst, idxNew + 2, src.length - idxNew - 2); + + return nodeOf(mutator, rawMap1() | bitpos, rawMap2() | bitpos, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + AtomicReference mutator, int bitpos, K key, V val) { + + // TODO: does not support src == dst yet for shifting + + final int idxOld = TUPLE_LENGTH * (arity(dataMap()) + index(collMap(), bitpos)); + final int idxNew = TUPLE_LENGTH * index(dataMap(), bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' + assert idxNew <= idxOld; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = key; + dst[idxNew + 1] = val; + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 2, dst, idxOld + 2, src.length - idxOld - 2); + + return nodeOf(mutator, rawMap1() ^ bitpos, rawMap2() | bitpos, dst); + } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(final AtomicReference mutator, + final int bitpos) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + return nodeOf(mutator, rawMap1(), rawMap2() ^ bitpos, dst); + } + + @Override + CompactSetMultimapNode copyAndRemoveCollection(final AtomicReference mutator, + final int bitpos) { + final int idx = TUPLE_LENGTH * (arity(dataMap()) + collIndex(bitpos)); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + return nodeOf(mutator, rawMap1() ^ bitpos, rawMap2() ^ bitpos, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToNode( + final AtomicReference mutator, final int bitpos, + final CompactSetMultimapNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] dst = copyAndMigrateFromXxxToNode(idxOld, idxNew, node); + + return nodeOf(mutator, rawMap1() | bitpos, rawMap2() ^ bitpos, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToNode(AtomicReference mutator, + int bitpos, CompactSetMultimapNode node) { + + final int idxOld = TUPLE_LENGTH * (arity(dataMap()) + index(collMap(), bitpos)); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] dst = copyAndMigrateFromXxxToNode(idxOld, idxNew, node); + + return nodeOf(mutator, rawMap1() | bitpos, rawMap2() ^ bitpos, dst); + } + + private Object[] copyAndMigrateFromXxxToNode(final int idxOld, final int idxNew, + final CompactSetMultimapNode node) { + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2 + 1]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 2, dst, idxNew + 1, src.length - idxNew - 2); + + return dst; + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton( + final AtomicReference mutator, final int bitpos, + final CompactSetMultimapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = TUPLE_LENGTH * dataIndex(bitpos); + + Object keyToInline = node.getSingletonKey(0); + Object valToInline = node.getSingletonValue(0); + + final Object[] dst = copyAndMigrateFromNodeToXxx(idxOld, idxNew, keyToInline, valToInline); + + return nodeOf(mutator, rawMap1() ^ bitpos, rawMap2() | bitpos, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToCollection(AtomicReference mutator, + int bitpos, CompactSetMultimapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = TUPLE_LENGTH * (arity(dataMap()) + index(collMap(), bitpos)); + + Object keyToInline = node.getCollectionKey(0); + Object valToInline = node.getCollectionValue(0); + + final Object[] dst = copyAndMigrateFromNodeToXxx(idxOld, idxNew, keyToInline, valToInline); + + return nodeOf(mutator, rawMap1() | bitpos, rawMap2() | bitpos, dst); + + } + + private Object[] copyAndMigrateFromNodeToXxx(final int idxOld, final int idxNew, + Object keyToInline, Object valToInline) { + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 2]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = keyToInline; + dst[idxNew + 1] = valToInline; + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 2, src.length - idxOld - 1); + + return dst; + } + + @Override + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + final int rawMap1, final int rawMap2) { + return nodeOf(mutator, rawMap1, rawMap2, nodes); + } + + @Override + EitherSingletonOrCollection.Type typeOfSingleton() { + assert this.sizePredicate() == SIZE_ONE; + + int rawMap1 = rawMap1(); + int rawMap2 = rawMap2(); + + if (rawMap1 != rawMap2) { + return EitherSingletonOrCollection.Type.SINGLETON; + } else { + return EitherSingletonOrCollection.Type.COLLECTION; + } + } + + @Override + CompactSetMultimapNode canonicalize(AtomicReference mutator, final int keyHash, + final int shift) { + if (shift > 0) { + int rawMap1 = rawMap1(); + int rawMap2 = rawMap2(); + + boolean slotCountEqualsTupleLength = nodes.length == TUPLE_LENGTH; + boolean containsPaylaod = rawMap2 != 0; + + if (slotCountEqualsTupleLength && containsPaylaod) { + int newBitmap = bitpos(mask(keyHash, 0)); + + if (rawMap1 != rawMap2) { + // is data payload + return copyAndUpdateBitmaps(mutator, 0, newBitmap); + } else { + // is coll payload + return copyAndUpdateBitmaps(mutator, newBitmap, newBitmap); + } + } + } + + // default + return this; + } + + } + + private static abstract class AbstractHashCollisionNode + extends CompactSetMultimapNode { + + static final > AbstractHashCollisionNode of( + final int hash, final K key0, final VS valColl0, final K key1, final VS valColl1) { + return new HashCollisionNode<>(hash, key0, valColl0, key1, valColl1); + } + + private static final RuntimeException UOE_BOILERPLATE = new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + private static final Supplier UOE_FACTORY = + () -> new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + @Override + int bitmap(int category) { + throw UOE_FACTORY.get(); + } + + @Override + int dataMap() { + throw UOE_FACTORY.get(); + } + + @Override + int collMap() { + throw UOE_FACTORY.get(); + } + + @Override + int nodeMap() { + throw UOE_FACTORY.get(); + } + + @Override + int rawMap1() { + throw UOE_FACTORY.get(); + } + + @Override + int rawMap2() { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, int rawMap1, + int rawMap2) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndSetSingletonValue(AtomicReference mutator, + int bitpos, V val) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndSetCollectionValue(AtomicReference mutator, + int bitpos, io.usethesource.capsule.Set.Immutable valColl) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndSetNode(AtomicReference mutator, int bitpos, + CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndInsertSingleton(AtomicReference mutator, int bitpos, + K key, V val) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + AtomicReference mutator, int bitpos, K key, + io.usethesource.capsule.Set.Immutable valColl) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(AtomicReference mutator, + int bitpos) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveCollection(AtomicReference mutator, + int bitpos) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToNode(AtomicReference mutator, + int bitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton(AtomicReference mutator, + int bitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToNode(AtomicReference mutator, + int bitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToCollection(AtomicReference mutator, + int bitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + AtomicReference mutator, int bitpos, K key, V val) { + throw UOE_FACTORY.get(); + } + + @Override + Type typeOfSingleton() { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode canonicalize(AtomicReference mutator, int keyHash, + int shift) { + throw UOE_FACTORY.get(); + } + } + + private static final class HashCollisionNode extends AbstractHashCollisionNode { + + private final int hash; + private final List>> collisionContent; + + HashCollisionNode(final int hash, final K key0, + final io.usethesource.capsule.Set.Immutable valColl0, final K key1, + final io.usethesource.capsule.Set.Immutable valColl1) { + this(hash, Arrays.asList(entryOf(key0, valColl0), entryOf(key1, valColl1))); + } + + HashCollisionNode(final int hash, + final List>> collisionContent) { + this.hash = hash; + this.collisionContent = collisionContent; + } + + @Override + public ArrayView> nodeArray() { + return ArrayView.empty(); + } + + private static final RuntimeException UOE = new UnsupportedOperationException(); + + private static final Supplier UOE_NOT_YET_IMPLEMENTED_FACTORY = + () -> new UnsupportedOperationException("Not yet implemented @ HashCollisionNode."); + + @Override + PersistentTrieSet.AbstractSetNode toSetNode(AtomicReference mutator) { + // is leaf; ignore mutator + return PersistentTrieSet.AbstractSetNode.newHashCollisonNode(hash, + (K[]) collisionContent.stream().map(Map.Entry::getKey).toArray()); + } + + // @Override + // PersistentTrieSet.AbstractSetNode toSetNode(PersistentTrieSet.AbstractSetNode[] newChildren) { + // // is leaf; ignore newChildren + // return PersistentTrieSet.AbstractSetNode.newHashCollisonNode(hash, + // (K[]) collisionContent.stream().map(Map.Entry::getKey).toArray()); + // } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + CompactSetMultimapNode getNode(int index) { + throw UOE; + } + + @Override + boolean hasPayload(Type type) { + switch (type) { + case SINGLETON: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).findAny() + .isPresent(); + case COLLECTION: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).findAny() + .isPresent(); + } + throw new RuntimeException(); + } + + @Override + int payloadArity(Type type) { + switch (type) { + case SINGLETON: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).count(); + case COLLECTION: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).count(); + } + throw new RuntimeException(); + } + + @Override + K getSingletonKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getKey(); + } + + @Override + V getSingletonValue(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getValue().stream().findAny().get(); + } + + @Override + K getCollectionKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getKey(); + } + + @Override + io.usethesource.capsule.Set.Immutable getCollectionValue(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getValue(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return collisionContent.size() * 2; + } + + @Override + Object getSlot(int index) { + if (index % 2 == 0) { + return collisionContent.get(index / 2).getKey(); + } else { + return collisionContent.get(index / 2).getValue(); + } + } + + @Override + boolean containsKey(K key, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny() + .isPresent(); + } + + @Override + boolean containsTuple(K key, V val, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) + && entry.getValue().containsEquivalent(val, cmp.toComparator())) + .findAny().isPresent(); + } + + @Override + Optional> findByKey(K key, int keyHash, + int shift, EqualityComparator cmp) { + return collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny() + .map(Map.Entry::getValue); + } + + @Override + CompactSetMultimapNode inserted(AtomicReference mutator, K key, V val, + int keyHash, int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + io.usethesource.capsule.Set.Immutable values = + optionalTuple.get().getValue(); + + if (values.containsEquivalent(val, cmp.toComparator())) { + // contains key and value + details.unchanged(); + return this; + + } else { + // contains key but not value + + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = + values.__insertEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + // TODO does not check that remainder is unmodified + assert updatedCollisionContent.size() == collisionContent.size(); + assert updatedCollisionContent.contains(optionalTuple.get()) == false; + // assert updatedCollisionContent.contains(entryOf(key, values.__insertEquivalent(val, + // cmp.toComparator()))); + assert updatedCollisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) + && entry.getValue().containsEquivalent(val, cmp.toComparator())) + .findAny().isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder() + .add(entryOf(key, io.usethesource.capsule.Set.Immutable.of(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + assert updatedCollisionContent.size() == collisionContent.size() + 1; + assert updatedCollisionContent.containsAll(collisionContent); + // assert updatedCollisionContent.contains(entryOf(key, setOf(val))); + assert updatedCollisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey()) + && Objects.equals(io.usethesource.capsule.Set.Immutable.of(val), entry.getValue())) + .findAny() + .isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode updated(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key -> replace val anyways + + io.usethesource.capsule.Set.Immutable values = + optionalTuple.get().getValue(); + + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = + values.__insertEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + if (values.size() == 1) { + details.updated(values.stream().findAny().get()); // unbox singleton + } else { + details.updated(values); + } + + return new HashCollisionNode(hash, updatedCollisionContent); + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder() + .add(entryOf(key, io.usethesource.capsule.Set.Immutable.of(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode removed(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + io.usethesource.capsule.Set.Immutable values = + optionalTuple.get().getValue(); + + if (values.containsEquivalent(val, cmp.toComparator())) { + // contains key and value -> remove mapping + + final List>> updatedCollisionContent; + + if (values.size() == 1) { + updatedCollisionContent = collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry != optionalTuple.get()) + .collect(Collectors.toList()); + } else { + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = + values.__removeEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + } + + details.updated(val); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + details.unchanged(); + return this; + } + + @Override + CompactSetMultimapNode removedAll(AtomicReference mutator, K key, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + final Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + io.usethesource.capsule.Set.Immutable values = + optionalTuple.get().getValue(); + + final List>> updatedCollisionContent; + + updatedCollisionContent = collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry != optionalTuple.get()) + .collect(Collectors.toList()); + + if (values.size() == 1) { + details.updated(values.stream().findFirst().get()); + return new HashCollisionNode(hash, updatedCollisionContent); + } else { + details.updated(values); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + details.unchanged(); + return this; + } + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueSingletonCursor; + protected int currentValueSingletonLength; + protected int currentValueCollectionCursor; + protected int currentValueCollectionLength; + protected AbstractSetMultimapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractSetMultimapNode[] nodes = new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapIterator(AbstractSetMultimapNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload(SINGLETON) || rootNode.hasPayload(COLLECTION)) { + currentValueNode = rootNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = rootNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = rootNode.payloadArity(COLLECTION); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractSetMultimapNode nextNode = + nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload(SINGLETON) || nextNode.hasPayload(COLLECTION)) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = nextNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = nextNode.payloadArity(COLLECTION); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueSingletonCursor < currentValueSingletonLength + || currentValueCollectionCursor < currentValueCollectionLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetMultimapKeyIterator extends AbstractSetMultimapIterator + implements Iterator { + + SetMultimapKeyIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return currentValueNode.getSingletonKey(currentValueSingletonCursor++); + } else { + return currentValueNode.getCollectionKey(currentValueCollectionCursor++); + } + } + } + + } + + protected static class SetMultimapValueIterator extends AbstractSetMultimapIterator + implements Iterator> { + + SetMultimapValueIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public io.usethesource.capsule.Set.Immutable next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return io.usethesource.capsule.Set.Immutable + .of(currentValueNode.getSingletonValue(currentValueSingletonCursor++)); + } else { + return currentValueNode.getCollectionValue(currentValueCollectionCursor++); + } + } + } + + } + + protected static class SetMultimapNativeTupleIterator + extends AbstractSetMultimapIterator implements Iterator> { + + SetMultimapNativeTupleIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + final K currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + final Object currentValue = + currentValueNode.getSingletonValue(currentValueSingletonCursor); + currentValueSingletonCursor++; + + return entryOf(currentKey, currentValue); + } else { + final K currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + final Object currentValue = + currentValueNode.getCollectionValue(currentValueCollectionCursor); + currentValueCollectionCursor++; + + return entryOf(currentKey, currentValue); + } + } + } + + } + + protected static class SetMultimapTupleIterator extends AbstractSetMultimapIterator + implements Iterator { + + final BiFunction tupleOf; + + K currentKey = null; + V currentValue = null; + Iterator currentSetIterator = Collections.emptyIterator(); + + SetMultimapTupleIterator(AbstractSetMultimapNode rootNode, + final BiFunction tupleOf) { + super(rootNode); + this.tupleOf = tupleOf; + } + + @Override + public boolean hasNext() { + if (currentSetIterator.hasNext()) { + return true; + } else { + if (super.hasNext()) { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + currentSetIterator = Collections + .singleton(currentValueNode.getSingletonValue(currentValueSingletonCursor)) + .iterator(); + currentValueSingletonCursor++; + } else { + currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + currentSetIterator = + currentValueNode.getCollectionValue(currentValueCollectionCursor).iterator(); + currentValueCollectionCursor++; + } + + return true; + } else { + return false; + } + } + } + + @Override + public T next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + currentValue = currentSetIterator.next(); + return tupleOf.apply(currentKey, currentValue); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieSetMultimap_BleedingEdgeNodeIterator + implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieSetMultimap_BleedingEdgeNodeIterator(AbstractSetMultimapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractSetMultimapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieSetMultimap_BleedingEdge + implements SetMultimap.Transient { + + private final EqualityComparator cmp; + + final private AtomicReference mutator; + private AbstractSetMultimapNode rootNode; + private int hashCode; + private int cachedSize; + private int cachedKeySetHashCode; + private int cachedKeySetSize; + + TransientTrieSetMultimap_BleedingEdge( + PersistentTrieSetMultimap trieSetMultimap_BleedingEdge) { + this.cmp = trieSetMultimap_BleedingEdge.cmp; + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieSetMultimap_BleedingEdge.rootNode; + this.hashCode = trieSetMultimap_BleedingEdge.hashCode; + this.cachedSize = trieSetMultimap_BleedingEdge.cachedSize; + this.cachedKeySetHashCode = trieSetMultimap_BleedingEdge.cachedKeySetHashCode; + this.cachedKeySetSize = trieSetMultimap_BleedingEdge.cachedKeySetSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize, entryIterator()); + assert checkKeySetHashCodeAndSize(cachedKeySetHashCode, cachedKeySetSize, keyIterator()); + } + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.equals(iterator.next(), o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get().contains(val); + } else { + return false; + } + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + // @Override + // public boolean __put(K key, Immutable valColl) { + // if (mutator.get() == null) { + // throw new IllegalStateException("Transient already frozen."); + // } + // + // final int keyHash = key.hashCode(); + // final SetMultimapResult details = SetMultimapResult.unchanged(); + // + // final CompactSetMultimapNode newRootNode = + // rootNode.updated(mutator, key, valColl, transformHashCode(keyHash), 0, details, cmp); + // + // if (details.isModified()) { + // if (details.hasReplacedValue()) { + // if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + // final int valHashOld = details.getReplacedValue().hashCode(); + // final int valHashNew = val.hashCode(); + // + // return new PersistentTrieSetMultimap(cmp, newRootNode, + // hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + // } else { + // int sumOfReplacedHashes = 0; + // + // for (V replaceValue : details.getReplacedCollection()) { + // sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + // } + // + // final int valHashNew = val.hashCode(); + // + // return new PersistentTrieSetMultimap(cmp, newRootNode, + // hashCode + ((keyHash ^ valHashNew)) - sumOfReplacedHashes, + // cachedSize - details.getReplacedCollection().size() + 1); + // } + // } + // + // final int valHash = val.hashCode(); + // return new PersistentTrieSetMultimap(cmp, newRootNode, hashCode + ((keyHash ^ valHash)), + // cachedSize + 1); + // } + // + // return false; + // } + + @Override + public boolean __insert(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + // TODO: support observability of what kind of modification was done internally + final int newKeySetHashCode; + final int newKeySetSize; + if (containsKey(key)) { + newKeySetHashCode = cachedKeySetHashCode; + newKeySetSize = cachedKeySetSize; + } else { + newKeySetHashCode = cachedKeySetHashCode + keyHash; + newKeySetSize = cachedKeySetSize + 1; + } + + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + cachedKeySetHashCode = newKeySetHashCode; + cachedKeySetSize = newKeySetSize; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize, entryIterator()); + assert checkKeySetHashCodeAndSize(cachedKeySetHashCode, cachedKeySetSize, keyIterator()); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize, entryIterator()); + assert checkKeySetHashCodeAndSize(cachedKeySetHashCode, cachedKeySetSize, keyIterator()); + } + return false; + } + + @Override + public boolean union(final SetMultimap setMultimap) { + boolean modified = false; + + for (Map.Entry entry : setMultimap.entrySet()) { + modified |= this.__insert(entry.getKey(), entry.getValue()); + } + + return modified; + } + + @Override + public boolean __remove(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + + // TODO: support observability of what kind of modification was done internally + final int newKeySetHashCode; + final int newKeySetSize; + if (newRootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp)) { + newKeySetHashCode = cachedKeySetHashCode; + newKeySetSize = cachedKeySetSize; + } else { + newKeySetHashCode = cachedKeySetHashCode - keyHash; + newKeySetSize = cachedKeySetSize - 1; + } + + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + cachedKeySetHashCode = newKeySetHashCode; + cachedKeySetSize = newKeySetSize; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize, entryIterator()); + assert checkKeySetHashCodeAndSize(cachedKeySetHashCode, cachedKeySetSize, keyIterator()); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize, entryIterator()); + assert checkKeySetHashCodeAndSize(cachedKeySetHashCode, cachedKeySetSize, keyIterator()); + } + + return false; + } + + @Override + public boolean __remove(K key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removedAll(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - ((keyHash ^ valHash)); + cachedSize = cachedSize - 1; + cachedKeySetHashCode = cachedKeySetHashCode - keyHash; + cachedKeySetSize = cachedKeySetSize - 1; + + return true; + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + rootNode = newRootNode; + hashCode = hashCode - sumOfReplacedHashes; + cachedSize = cachedSize - details.getReplacedCollection().size(); + cachedKeySetHashCode = cachedKeySetHashCode - keyHash; + cachedKeySetSize = cachedKeySetSize - 1; + + return true; + } + } + + return false; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new TransientSetMultimapKeyIterator<>(this); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(Set::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + return new TransientSetMultimapTupleIterator<>(this, + AbstractSpecialisedImmutableMap::entryOf); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new TransientSetMultimapTupleIterator<>(this, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see + * Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + public static class TransientSetMultimapKeyIterator extends SetMultimapKeyIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + K lastKey; + + public TransientSetMultimapKeyIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapValueIterator + extends SetMultimapValueIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapValueIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public io.usethesource.capsule.Set.Immutable next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapTupleIterator + extends SetMultimapTupleIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapTupleIterator( + final TransientTrieSetMultimap_BleedingEdge collection, + final BiFunction tupleOf) { + super(collection.rootNode, tupleOf); + this.collection = collection; + } + + @Override + public T next() { + return super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(currentKey, currentValue); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieSetMultimap_BleedingEdge.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieSetMultimap_BleedingEdge) { + TransientTrieSetMultimap_BleedingEdge that = + (TransientTrieSetMultimap_BleedingEdge) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + final io.usethesource.capsule.Set.Immutable valColl = + (io.usethesource.capsule.Set.Immutable) entry.getValue(); + + if (!cmp.equals(result.get(), valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public SetMultimap.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + // TODO: add transient suppor for caching of keySet data. + mutator.set(null); + return new PersistentTrieSetMultimap(cmp, rootNode, hashCode, cachedSize, -1, -1); + } + } + +} diff --git a/capsule-core/src/main/java/io/usethesource/capsule/core/trie/ArrayView.java b/capsule-core/src/main/java/io/usethesource/capsule/core/trie/ArrayView.java new file mode 100644 index 0000000..535646f --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/core/trie/ArrayView.java @@ -0,0 +1,102 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.core.trie; + +import java.util.ListIterator; +import java.util.concurrent.atomic.AtomicReference; + +/** + * Invariant array interface. + * + * @param element type of array + */ +public interface ArrayView extends Iterable { + + int size(); + + T get(int index); + + default void set(int index, T item) { + throw new UnsupportedOperationException(); + } + + default void set(int index, T item, AtomicReference writeCapabilityToken) { + throw new UnsupportedOperationException(); + } + + @Override + default ListIterator iterator() { + return new ListIterator() { + private volatile int current = 0; + private volatile int previous = -1; + + @Override + public boolean hasNext() { + return current < ArrayView.this.size(); + } + + @Override + public T next() { + return ArrayView.this.get(previous = current++); + } + + @Override + public boolean hasPrevious() { + return current >= 0; + } + + @Override + public T previous() { + return ArrayView.this.get(previous = current--); + } + + @Override + public int nextIndex() { + return current + 1; + } + + @Override + public int previousIndex() { + return current - 1; + } + + @Override + public void set(T t) { + if (previous == -1) + throw new IllegalStateException(); + + ArrayView.this.set(previous, t); + } + + @Override + public void add(T t) { + throw new UnsupportedOperationException(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + }; + } + + static ArrayView empty() { + return new ArrayView() { + @Override + public int size() { + return 0; + } + + @Override + public T get(int index) { + throw new IndexOutOfBoundsException(); + } + }; + } + +} diff --git a/capsule-core/src/main/java/io/usethesource/capsule/core/trie/BottomUpImmutableNodeTransformer.java b/capsule-core/src/main/java/io/usethesource/capsule/core/trie/BottomUpImmutableNodeTransformer.java new file mode 100644 index 0000000..3c7d372 --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/core/trie/BottomUpImmutableNodeTransformer.java @@ -0,0 +1,264 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +// package io.usethesource.capsule.core.trie; +// +// import java.util.Iterator; +// import java.util.NoSuchElementException; +// import java.util.Stack; +// import java.util.function.BiFunction; +// +// import io.usethesource.capsule.core.deprecated.PersistentTrieSet; +// import io.usethesource.capsule.core.PersistentTrieSetMultimap; +// +/// ** +// * Basic support for both PUSH- and PULL-based data processing. Still needs tweaking of the +// * interface and implementation, but the the functionality is there. +// */ +// public class BottomUpImmutableNodeTransformer, SN extends +/// PersistentTrieSet.AbstractSetNode> +// implements Iterator { +// +// static final , SN extends +/// PersistentTrieSet.AbstractSetNode> SN applyNodeTransformation( +// final MN rootNode, final BiFunction nodeMapper) { +// +// BottomUpImmutableNodeTransformer transformer = +// new BottomUpImmutableNodeTransformer<>(rootNode, nodeMapper); +// transformer.applyNodeTranformation(PersistentTrieSetMultimap.StreamType.PUSH); +// return transformer.mappedNodesStack.peek(); +// } +// +// private static final int MAX_DEPTH = 7; +// +// private final BiFunction nodeMapper; +// +// boolean isNextAvailable; +// private int currentStackLevel; +// private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; +// +// final MN[] nodes = (MN[]) new PersistentTrieSetMultimap.AbstractSetMultimapNode[MAX_DEPTH]; +// +// final Stack mappedNodesStack = new Stack(); +// +// private final static PersistentTrieSet.AbstractSetNode[] EMPTY_SN_ARRAY = +// new PersistentTrieSet.AbstractSetNode[] {}; +// +// BottomUpImmutableNodeTransformer(final MN rootNode, final BiFunction nodeMapper) { +// mappedNodesStack.ensureCapacity(128); +// +// this.nodeMapper = nodeMapper; +// +// if (rootNode.hasNodes()) { +// // rootNode == non-leaf node +// currentStackLevel = 0; +// isNextAvailable = false; +// +// nodes[0] = rootNode; +// nodeCursorsAndLengths[0] = 0; +// nodeCursorsAndLengths[1] = rootNode.nodeArity(); +// } else { +// currentStackLevel = -1; +// isNextAvailable = true; +// +// mappedNodesStack.push(nodeMapper.apply(rootNode, (SN[]) EMPTY_SN_ARRAY)); +// // mappedNodesStack.push((SN) rootNode.toSetNode(EMPTY_SN_ARRAY)); +// // System.err.println(String.format("mappedNodesStack.size == %d", +// // mappedNodesStack.size())); +// // MAX_STACK_SIZE = Math.max(MAX_STACK_SIZE, mappedNodesStack.size()); +// } +// } +// +// /* +// * search for next node that can be mapped +// */ +// private boolean applyNodeTranformation(final PersistentTrieSetMultimap.StreamType streamType) { +// while (currentStackLevel >= 0) { +// final int currentCursorIndex = currentStackLevel * 2; +// final int currentLengthIndex = currentCursorIndex + 1; +// +// final int childNodeCursor = nodeCursorsAndLengths[currentCursorIndex]; +// final int childNodeLength = nodeCursorsAndLengths[currentLengthIndex]; +// +// if (childNodeCursor < childNodeLength) { +// final MN nextNode = (MN) nodes[currentStackLevel].getNode(childNodeCursor); +// nodeCursorsAndLengths[currentCursorIndex]++; +// +// if (nextNode.hasNodes()) { +// // root node == non-leaf node +// // put node on next stack level for depth-first traversal +// final int nextStackLevel = ++currentStackLevel; +// final int nextCursorIndex = nextStackLevel * 2; +// final int nextLengthIndex = nextCursorIndex + 1; +// +// nodes[nextStackLevel] = nextNode; +// nodeCursorsAndLengths[nextCursorIndex] = 0; +// nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); +// } else { +// // nextNode == leaf node +// mappedNodesStack.push(nodeMapper.apply(nextNode, (SN[]) EMPTY_SN_ARRAY)); +// // mappedNodesStack.push((SN) nextNode.toSetNode(EMPTY_SN_ARRAY)); +// // System.err.println(String.format("mappedNodesStack.size == %d", +// // mappedNodesStack.size())); +// // MAX_STACK_SIZE = Math.max(MAX_STACK_SIZE, mappedNodesStack.size()); +// +// if (streamType == PersistentTrieSetMultimap.StreamType.PULL) { +// return true; +// } +// } +// } else { +// // pop all children +// assert childNodeLength != 0; +// SN[] newChildren = (SN[]) new PersistentTrieSet.AbstractSetNode[childNodeLength]; +// for (int i = childNodeLength - 1; i >= 0; i--) { +// newChildren[i] = mappedNodesStack.pop(); +// } +// +// // apply mapper, push mapped node +// mappedNodesStack.push(nodeMapper.apply(nodes[currentStackLevel], newChildren)); +// // mappedNodesStack.push((SN) nodes[currentStackLevel].toSetNode(newChildren)); +// // System.err.println(String.format("mappedNodesStack.size == %d", +// // mappedNodesStack.size())); +// // MAX_STACK_SIZE = Math.max(MAX_STACK_SIZE, mappedNodesStack.size()); +// currentStackLevel--; +// +// if (streamType == PersistentTrieSetMultimap.StreamType.PULL) { +// return true; +// } +// } +// } +// +// // TODO: this is mind tangling; rework +// if (streamType == PersistentTrieSetMultimap.StreamType.PUSH) { +// return true; +// } else { +// return false; +// } +// } +// +// @Override +// public boolean hasNext() { +// if (currentStackLevel >= -1 && isNextAvailable) { +// return true; +// } else { +// return isNextAvailable = applyNodeTranformation(PersistentTrieSetMultimap.StreamType.PULL); +// } +// } +// +// /** +// * Returns transformed --either internal or leaf-- node. +// * +// * @return mapped node +// */ +// @Override +// public SN next() { +// if (!hasNext()) { +// throw new NoSuchElementException(); +// } else { +// isNextAvailable = false; +// return mappedNodesStack.peek(); +// } +// } +// +// @Override +// public void remove() { +// throw new UnsupportedOperationException(); +// } +// +// public SN result() { +// assert !hasNext(); +// return mappedNodesStack.peek(); +// } +// +// } +// +// +// enum StreamType { +// PULL, PUSH +// } +// +//// private static final int MAX_DEPTH = 7; +//// private final static Class MAP_CLASS = AbstractSetMultimapNode.class; +//// private final static Class SET_CLASS = PersistentTrieSet.AbstractSetNode.class; +//// +//// public static final , SN extends +//// PersistentTrieSet.AbstractSetNode> Optional applyNodeTransformation( +//// final MN mapRootNode, final BiFunction, SN> nodeMapper) { +//// +//// final AtomicReference mutator = new AtomicReference<>(Thread.currentThread()); +//// +//// final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; +//// final MN[] mapNodes = (MN[]) Array.newInstance(MAP_CLASS, MAX_DEPTH); +//// final SN[] setNodes = (SN[]) Array.newInstance(SET_CLASS, MAX_DEPTH); +//// +//// int currentStackLevel; +//// +//// /************/ +//// /*** INIT ***/ +//// /************/ +//// +//// final SN setRootNode = nodeMapper.apply(mapRootNode, mutator); +//// +//// if (mapRootNode.hasNodes()) { +//// // rootNode == non-leaf node +//// currentStackLevel = 0; +//// +//// mapNodes[0] = mapRootNode; +//// setNodes[0] = setRootNode; +//// +//// nodeCursorsAndLengths[0] = 0; +//// nodeCursorsAndLengths[1] = mapRootNode.nodeArity(); +//// } else { +//// // nextNode == leaf node +//// currentStackLevel = -1; +//// return Optional.of(setRootNode); +//// } +//// +//// /************/ +//// /*** BODY ***/ +//// /************/ +//// +//// while (currentStackLevel >= 0) { +//// final int currentCursorIndex = currentStackLevel * 2; +//// final int currentLengthIndex = currentCursorIndex + 1; +//// +//// final int childNodeCursor = nodeCursorsAndLengths[currentCursorIndex]; +//// final int childNodeLength = nodeCursorsAndLengths[currentLengthIndex]; +//// +//// if (childNodeCursor < childNodeLength) { +//// final MN nextMapNode = (MN) mapNodes[currentStackLevel].getNode(childNodeCursor); +//// nodeCursorsAndLengths[currentCursorIndex]++; +//// +//// final SN nextSetNode = nodeMapper.apply(nextMapNode, mutator); +//// setNodes[currentStackLevel].setNode(mutator, childNodeCursor, nextSetNode); +//// +//// if (nextMapNode.hasNodes()) { +//// // root node == non-leaf node +//// // put node on next stack level for depth-first traversal +//// final int nextStackLevel = ++currentStackLevel; +//// final int nextCursorIndex = nextStackLevel * 2; +//// final int nextLengthIndex = nextCursorIndex + 1; +//// +//// mapNodes[nextStackLevel] = nextMapNode; +//// setNodes[nextStackLevel] = nextSetNode; +//// nodeCursorsAndLengths[nextCursorIndex] = 0; +//// nodeCursorsAndLengths[nextLengthIndex] = nextMapNode.nodeArity(); +//// } else { +//// // nextNode == (finished) leaf node +//// } +//// } else { +//// // nextNode == (finished) intermediate node +//// +//// // pop from stack +//// currentStackLevel--; +//// } +//// } +//// +//// // yield set's rootNode +//// return Optional.of(setNodes[0]); +//// } diff --git a/capsule-core/src/main/java/io/usethesource/capsule/core/trie/BottomUpTransientNodeTransformer.java b/capsule-core/src/main/java/io/usethesource/capsule/core/trie/BottomUpTransientNodeTransformer.java new file mode 100644 index 0000000..20605cc --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/core/trie/BottomUpTransientNodeTransformer.java @@ -0,0 +1,187 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.core.trie; + +import java.util.ListIterator; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.BiFunction; + +/** + * Mapper that traverses a trie and converts each node (of {@code SN}) to a node of type {@code DN}. + */ +public class BottomUpTransientNodeTransformer { + + private static final int MAX_DEPTH = 7; + + private final BiFunction, DN> nodeMapper; + private final AtomicReference mutator; + private final DN dstRootNode; + + private int stackIndex = -1; + private final ListIterator[] srcIteratorStack = new ListIterator[MAX_DEPTH]; + private final ListIterator[] dstIteratorStack = new ListIterator[MAX_DEPTH]; + + public BottomUpTransientNodeTransformer(final SN srcRootNode, + final BiFunction, DN> nodeMapper) { + this.nodeMapper = nodeMapper; + this.mutator = new AtomicReference<>(Thread.currentThread()); + this.dstRootNode = nodeMapper.apply(srcRootNode, mutator); + + final ListIterator srcIterator = (ListIterator) srcRootNode.nodeArray().iterator(); + + if (srcIterator.hasNext()) { + final ListIterator dstIterator = (ListIterator) dstRootNode.nodeArray().iterator(); + + pushOnStack(srcIterator, dstIterator); + } + } + + public final DN apply() { + if (!isStackEmpty()) { + processStack(); + } + + mutator.set(null); + return dstRootNode; + } + + private final boolean isStackEmpty() { + return stackIndex == -1; + } + + private final void pushOnStack(ListIterator srcNode, ListIterator dstNode) { + // push on stack + final int nextIndex = ++stackIndex; + srcIteratorStack[nextIndex] = srcNode; + dstIteratorStack[nextIndex] = dstNode; + } + + private final void dropFromStack() { + // pop from stack + final int previousIndex = stackIndex--; + srcIteratorStack[previousIndex] = null; + dstIteratorStack[previousIndex] = null; + } + + /* + * Traverse trie and convert nodes at first encounter. Sub-trie references are updated + * incrementally throughout iteration. + */ + private final void processStack() { + while (!isStackEmpty()) { + final ListIterator srcIterator = srcIteratorStack[stackIndex]; + final ListIterator dstIterator = dstIteratorStack[stackIndex]; + + boolean stackModified = false; + while (!stackModified) { + if (srcIterator.hasNext()) { + final SN src = srcIterator.next(); + final DN dst = nodeMapper.apply(src, mutator); + + dstIterator.next(); + dstIterator.set(dst); + + final ListIterator nextSrcIterator = (ListIterator) src.nodeArray().iterator(); + + if (nextSrcIterator.hasNext()) { + final ListIterator nextDstIterator = (ListIterator) dst.nodeArray().iterator(); + + pushOnStack(nextSrcIterator, nextDstIterator); + stackModified = true; + } + } else { + dropFromStack(); + stackModified = true; + } + } + } + } + + // /* + // * search for next node that can be mapped + // */ + // private final Optional applyNodeTranformation(boolean yieldIntermediate) { + // SN result = null; + // + // while (stackLevel >= 0 && result == null) { + // final ListIterator srcSubNodeIterator = srcIteratorStack[stackLevel]; + // final ListIterator dstSubNodeIterator = dstIteratorStack[stackLevel]; + // + // if (srcSubNodeIterator.hasNext()) { + // final MN nextMapNode = srcSubNodeIterator.next(); + // final SN nextSetNode = nodeMapper.apply(nextMapNode, mutator); + // + // dstSubNodeIterator.next(); + // dstSubNodeIterator.set(nextSetNode); + // + // final ListIterator subNodeIterator = + // (ListIterator) nextMapNode.nodeArray().iterator(); + // + // if (subNodeIterator.hasNext()) { + // // next node == (to process) intermediate node + // // put node on next stack level for depth-first traversal + //// final SN nextSetNode = nodeMapper.apply(nextMapNode, mutator); + // + // final int nextStackLevel = ++stackLevel; + // srcIteratorStack[nextStackLevel] = subNodeIterator; + // dstIteratorStack[nextStackLevel] = + // (ListIterator) nextSetNode.nodeArray().iterator(); + // } else if (yieldIntermediate) { + // // nextNode == (finished) leaf node + // result = nextSetNode; + // } + // } else { + // if (yieldIntermediate) { + // // nextNode == (finished) intermidate node + // // result = setNodes[stackLevel]; // ??? + // throw new IllegalStateException("TODO: figure out how to return previous element."); + // } else if (stackLevel == 0) { + // result = setRootNode; + // } + // + // // pop from stack + // srcIteratorStack[stackLevel] = null; + // dstIteratorStack[stackLevel] = null; + // stackLevel--; + // } + // } + // + // return Optional.ofNullable(result); + // } + + // @Override + // public boolean hasNext() { + // if (next.get().isPresent()) { + // return true; + // } else { + // final Optional result = applyNodeTranformation(true); + // next.set(result); + // return result.isPresent(); + // } + // } + // + // /** + // * Returns transformed --either internal or leaf-- node. + // * + // * @return mapped node + // */ + // @Override + // public SN next() { + // if (!hasNext()) { + // throw new NoSuchElementException(); + // } else { + // return next.getAndSet(Optional.empty()).get(); + // } + // } + // + // @Override + // public void remove() { + // throw new UnsupportedOperationException(); + // } + +} diff --git a/capsule-core/src/main/java/io/usethesource/capsule/core/trie/Node.java b/capsule-core/src/main/java/io/usethesource/capsule/core/trie/Node.java new file mode 100644 index 0000000..26e9b29 --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/core/trie/Node.java @@ -0,0 +1,34 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.core.trie; + +public interface Node { + + // boolean hasNodes(); + // + // int nodeArity(); + // + // INode getNode(final int index); + // + // default void setNode(final AtomicReference mutator, final int index, final INode node) + // { + // throw new UnsupportedOperationException("Immutable."); + // } + + default ArrayView dataArray(int category, int component) { + throw new UnsupportedOperationException("Experimental and only partially supported."); + } + + ArrayView nodeArray(); + + // /** TODO: create local stream transformer */ + // default Stream localStream() { + // return new Spliterators.spliterator(dataArray()); + // } + +} diff --git a/src/main/java/io/usethesource/capsule/ArrayUtils.java b/capsule-core/src/main/java/io/usethesource/capsule/util/ArrayUtils.java similarity index 96% rename from src/main/java/io/usethesource/capsule/ArrayUtils.java rename to capsule-core/src/main/java/io/usethesource/capsule/util/ArrayUtils.java index 5238a18..25cd00a 100644 --- a/src/main/java/io/usethesource/capsule/ArrayUtils.java +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/ArrayUtils.java @@ -5,10 +5,14 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; +package io.usethesource.capsule.util; public class ArrayUtils { + public static final T[] arrayOf(T... items) { + return items; + } + public static boolean equals(Object[] a1, Object[] a2) { if (null == a1 || null == a2) { return false; diff --git a/src/main/java/io/usethesource/capsule/ArrayUtilsInt.java b/capsule-core/src/main/java/io/usethesource/capsule/util/ArrayUtilsInt.java similarity index 73% rename from src/main/java/io/usethesource/capsule/ArrayUtilsInt.java rename to capsule-core/src/main/java/io/usethesource/capsule/util/ArrayUtilsInt.java index 1d4c6d9..e0f5808 100644 --- a/src/main/java/io/usethesource/capsule/ArrayUtilsInt.java +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/ArrayUtilsInt.java @@ -5,11 +5,15 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; +package io.usethesource.capsule.util; public class ArrayUtilsInt { - static int[] arraycopyAndInsertInt(final int[] src, final int idx, final int value) { + public static final int[] arrayOfInt(int... items) { + return items; + } + + public static int[] arraycopyAndInsertInt(final int[] src, final int idx, final int value) { final int[] dst = new int[src.length + 1]; // copy 'src' and insert 1 element(s) at position 'idx' @@ -20,7 +24,7 @@ static int[] arraycopyAndInsertInt(final int[] src, final int idx, final int val return dst; } - static int[] arraycopyAndRemoveInt(final int[] src, final int idx) { + public static int[] arraycopyAndRemoveInt(final int[] src, final int idx) { final int[] dst = new int[src.length - 1]; // copy 'src' and remove 1 element(s) at position 'idx' diff --git a/capsule-core/src/main/java/io/usethesource/capsule/util/BitmapUtils.java b/capsule-core/src/main/java/io/usethesource/capsule/util/BitmapUtils.java new file mode 100644 index 0000000..8b07730 --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/BitmapUtils.java @@ -0,0 +1,160 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.util; + +public final class BitmapUtils { + + private static final boolean USE_SELF_WRITTEN_POPULATION_COUNT = false; + private static final boolean USE_SELF_WRITTEN_POPULATION_COUNT_CHECK = + !USE_SELF_WRITTEN_POPULATION_COUNT && false; + + public static final long filter00(long bitmap) { + return ((bitmap & 0x5555555555555555L) ^ 0x5555555555555555L) + & (((bitmap >> 1) & 0x5555555555555555L) ^ 0x5555555555555555L); + } + + public static final long filter01(long bitmap) { + return (bitmap & 0x5555555555555555L) + & (((bitmap >> 1) & 0x5555555555555555L) ^ 0x5555555555555555L); + } + + public static final long filter10(long bitmap) { + return ((bitmap & 0x5555555555555555L) ^ 0x5555555555555555L) + & ((bitmap >> 1) & 0x5555555555555555L); + } + + public static final long filter11(long bitmap) { + return (bitmap & 0x5555555555555555L) & ((bitmap >> 1) & 0x5555555555555555L); + } + + public static final long filter(long bitmap, int pattern) { + switch (pattern) { + case 0b00: + return filter00(bitmap); + case 0b01: + return filter01(bitmap); + case 0b10: + return filter10(bitmap); + case 0b11: + return filter11(bitmap); + default: + throw new IllegalArgumentException(); + } + } + + public static final int index(long bitmap, int pattern, long bitpos) { + return java.lang.Long.bitCount(filter(bitmap, pattern) & (bitpos - 1)); + } + + public static final int index01(final long bitmap, final long bitpos) { + if (USE_SELF_WRITTEN_POPULATION_COUNT) { + return (int) populationCountPattern01(bitmap & (bitpos - 1)); + } else { + // final long filteredBitmap = (bitmap & 0x5555555555555555L) + // & (((bitmap >> 1) & 0x5555555555555555L) ^ 0x5555555555555555L); + final long filteredBitmap = filter01(bitmap); + final int index = java.lang.Long.bitCount(filteredBitmap & (bitpos - 1)); + + if (USE_SELF_WRITTEN_POPULATION_COUNT_CHECK) { + final int otherIndex = (int) populationCountPattern01(bitmap & (bitpos - 1)); + if (index != otherIndex) { + throw new IllegalStateException(index + "!=" + otherIndex); + } + } + + return index; + } + } + + public static final int index10(final long bitmap, final long bitpos) { + if (USE_SELF_WRITTEN_POPULATION_COUNT) { + return (int) populationCountPattern10(bitmap & (bitpos - 1)); + } else { + // final long filteredBitmap = ((bitmap & 0x5555555555555555L) ^ 0x5555555555555555L) + // & ((bitmap >> 1) & 0x5555555555555555L); + final long filteredBitmap = filter10(bitmap); + final int index = java.lang.Long.bitCount(filteredBitmap & (bitpos - 1)); + + if (USE_SELF_WRITTEN_POPULATION_COUNT_CHECK) { + final int otherIndex = (int) populationCountPattern10(bitmap & (bitpos - 1)); + if (index != otherIndex) { + throw new IllegalStateException(index + "!=" + otherIndex); + } + } + + return index; + } + } + + public static final int index11(final long bitmap, final long bitpos) { + if (USE_SELF_WRITTEN_POPULATION_COUNT) { + return (int) populationCountPattern11(bitmap & (bitpos - 1)); + } else { + // final long filteredBitmap = + // (bitmap & 0x5555555555555555L) & ((bitmap >> 1) & 0x5555555555555555L); + final long filteredBitmap = filter11(bitmap); + final int index = java.lang.Long.bitCount(filteredBitmap & (bitpos - 1)); + + if (USE_SELF_WRITTEN_POPULATION_COUNT_CHECK) { + final int otherIndex = (int) populationCountPattern11(bitmap & (bitpos - 1)); + if (index != otherIndex) { + throw new IllegalStateException(index + "!=" + otherIndex); + } + } + + return index; + } + } + + public static final long populationCountPattern00(long v) { + long c = ((v & 0x5555555555555555L) ^ 0x5555555555555555L) + & (((v >> 1) & 0x5555555555555555L) ^ 0x5555555555555555L); + c = (c & 0x3333333333333333L) + ((c >> 2) & 0x3333333333333333L); + c = (c & 0x0F0F0F0F0F0F0F0FL) + ((c >> 4) & 0x0F0F0F0F0F0F0F0FL); + c = (c & 0x00FF00FF00FF00FFL) + ((c >> 8) & 0x00FF00FF00FF00FFL); + c = (c & 0x0000FFFF0000FFFFL) + ((c >> 16) & 0x0000FFFF0000FFFFL); + return c; + } + + public static final long populationCountPattern01(long v) { + long c = (v & 0x5555555555555555L) & (((v >> 1) & 0x5555555555555555L) ^ 0x5555555555555555L); + c = (c & 0x3333333333333333L) + ((c >> 2) & 0x3333333333333333L); + c = (c & 0x0F0F0F0F0F0F0F0FL) + ((c >> 4) & 0x0F0F0F0F0F0F0F0FL); + c = (c & 0x00FF00FF00FF00FFL) + ((c >> 8) & 0x00FF00FF00FF00FFL); + c = (c & 0x0000FFFF0000FFFFL) + ((c >> 16) & 0x0000FFFF0000FFFFL); + return c; + } + + public static final long populationCountPattern10(long v) { + long c = ((v & 0x5555555555555555L) ^ 0x5555555555555555L) & ((v >> 1) & 0x5555555555555555L); + c = (c & 0x3333333333333333L) + ((c >> 2) & 0x3333333333333333L); + c = (c & 0x0F0F0F0F0F0F0F0FL) + ((c >> 4) & 0x0F0F0F0F0F0F0F0FL); + c = (c & 0x00FF00FF00FF00FFL) + ((c >> 8) & 0x00FF00FF00FF00FFL); + c = (c & 0x0000FFFF0000FFFFL) + ((c >> 16) & 0x0000FFFF0000FFFFL); + return c; + } + + public static final long populationCountPattern11(long v) { + long c = (v & 0x5555555555555555L) & ((v >> 1) & 0x5555555555555555L); + c = (c & 0x3333333333333333L) + ((c >> 2) & 0x3333333333333333L); + c = (c & 0x0F0F0F0F0F0F0F0FL) + ((c >> 4) & 0x0F0F0F0F0F0F0F0FL); + c = (c & 0x00FF00FF00FF00FFL) + ((c >> 8) & 0x00FF00FF00FF00FFL); + c = (c & 0x0000FFFF0000FFFFL) + ((c >> 16) & 0x0000FFFF0000FFFFL); + return c; + } + + public static boolean isBitInBitmap(byte bitmap, byte bitpos) { + return (bitmap != 0 && (bitmap == -1 || (bitmap & bitpos) != 0)); + // return (bitmap & bitpos) != 0; + } + + public static boolean isBitInBitmap(int bitmap, int bitpos) { + return (bitmap != 0 && (bitmap == -1 || (bitmap & bitpos) != 0)); + // return (bitmap & bitpos) != 0; + } +} diff --git a/capsule-core/src/main/java/io/usethesource/capsule/util/EqualityComparator.java b/capsule-core/src/main/java/io/usethesource/capsule/util/EqualityComparator.java new file mode 100644 index 0000000..fa91fb7 --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/EqualityComparator.java @@ -0,0 +1,24 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.util; + +import java.util.Comparator; +import java.util.Objects; + +@FunctionalInterface +public interface EqualityComparator { + + EqualityComparator EQUALS = (a, b) -> Objects.equals(a, b); + + boolean equals(T o1, T o2); + + default Comparator toComparator() { + return ((o1, o2) -> equals(o1, o2) == true ? 0 : -1); + } + +} diff --git a/src/main/java/io/usethesource/capsule/AbstractImmutableMap.java b/capsule-core/src/main/java/io/usethesource/capsule/util/collection/AbstractImmutableMap.java similarity index 88% rename from src/main/java/io/usethesource/capsule/AbstractImmutableMap.java rename to capsule-core/src/main/java/io/usethesource/capsule/util/collection/AbstractImmutableMap.java index d5b2a0c..894b108 100644 --- a/src/main/java/io/usethesource/capsule/AbstractImmutableMap.java +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/collection/AbstractImmutableMap.java @@ -5,14 +5,14 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; +package io.usethesource.capsule.util.collection; import java.util.AbstractMap; import java.util.Map; @Deprecated public abstract class AbstractImmutableMap extends AbstractMap - implements ImmutableMap { + implements io.usethesource.capsule.Map.Immutable { @Override public V remove(Object key) { diff --git a/src/main/java/io/usethesource/capsule/AbstractImmutableSet.java b/capsule-core/src/main/java/io/usethesource/capsule/util/collection/AbstractImmutableSet.java similarity index 90% rename from src/main/java/io/usethesource/capsule/AbstractImmutableSet.java rename to capsule-core/src/main/java/io/usethesource/capsule/util/collection/AbstractImmutableSet.java index 3d4ef36..4913598 100644 --- a/src/main/java/io/usethesource/capsule/AbstractImmutableSet.java +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/collection/AbstractImmutableSet.java @@ -5,14 +5,16 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; +package io.usethesource.capsule.util.collection; import java.util.AbstractSet; import java.util.Collection; import java.util.Comparator; +import io.usethesource.capsule.Set; + @Deprecated -public abstract class AbstractImmutableSet extends AbstractSet implements ImmutableSet { +public abstract class AbstractImmutableSet extends AbstractSet implements Set.Immutable { @Override public boolean add(E e) { @@ -50,7 +52,7 @@ public boolean isTransientSupported() { } @Override - public TransientSet asTransient() { + public Set.Transient asTransient() { throw new UnsupportedOperationException(); } diff --git a/src/main/java/io/usethesource/capsule/AbstractSpecialisedImmutableMap.java b/capsule-core/src/main/java/io/usethesource/capsule/util/collection/AbstractSpecialisedImmutableMap.java similarity index 84% rename from src/main/java/io/usethesource/capsule/AbstractSpecialisedImmutableMap.java rename to capsule-core/src/main/java/io/usethesource/capsule/util/collection/AbstractSpecialisedImmutableMap.java index fdc5e71..020a90c 100644 --- a/src/main/java/io/usethesource/capsule/AbstractSpecialisedImmutableMap.java +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/collection/AbstractSpecialisedImmutableMap.java @@ -5,59 +5,75 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; +package io.usethesource.capsule.util.collection; -import java.util.*; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Iterator; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Set; + +import io.usethesource.capsule.util.iterator.EmptySupplierIterator; +import io.usethesource.capsule.util.iterator.SupplierIterator; public abstract class AbstractSpecialisedImmutableMap - implements ImmutableMap, Cloneable { - @SuppressWarnings("rawtypes") - private static ImmutableMap EMPTY_MAP = new Map0(); + implements io.usethesource.capsule.Map.Immutable, Cloneable { + + private static io.usethesource.capsule.Map.Immutable EMPTY_MAP = new Map0(); - @SuppressWarnings("unchecked") - public static ImmutableMap mapOf() { + public static io.usethesource.capsule.Map.Immutable mapOf() { return EMPTY_MAP; } - @SuppressWarnings("unchecked") - public static final > T entryOf(final K key, final V val) { - return (T) new MapEntry(key, val); + public static final Map.Entry entryOf(final K key, final V val) { + return new MapEntry(key, val); } - public static ImmutableMap mapOf(K key1, V val1) { + public static io.usethesource.capsule.Map.Immutable mapOf(K key1, V val1) { return new Map1(key1, val1); } - public static ImmutableMap mapOf(K key1, V val1, K key2, V val2) { + public static io.usethesource.capsule.Map.Immutable mapOf(K key1, V val1, K key2, + V val2) { return new Map2(key1, val1, key2, val2); } - public static ImmutableMap mapOf(K key1, V val1, K key2, V val2, K key3, V val3) { + public static io.usethesource.capsule.Map.Immutable mapOf(K key1, V val1, K key2, + V val2, K key3, V val3) { return new Map3(key1, val1, key2, val2, key3, val3); } - public static ImmutableMap mapOf(K key1, V val1, K key2, V val2, K key3, V val3, + public static io.usethesource.capsule.Map.Immutable mapOf(K key1, V val1, K key2, + V val2, K key3, V val3, K key4, V val4) { return new Map4(key1, val1, key2, val2, key3, val3, key4, val4); } - public static ImmutableMap mapOf(K key1, V val1, K key2, V val2, K key3, V val3, + public static io.usethesource.capsule.Map.Immutable mapOf(K key1, V val1, K key2, + V val2, K key3, V val3, K key4, V val4, K key5, V val5) { return new Map5(key1, val1, key2, val2, key3, val3, key4, val4, key5, val5); } - public static ImmutableMap mapOf(K key1, V val1, K key2, V val2, K key3, V val3, + public static io.usethesource.capsule.Map.Immutable mapOf(K key1, V val1, K key2, + V val2, K key3, V val3, K key4, V val4, K key5, V val5, K key6, V val6) { - final TransientMap tmp = DefaultTrieMap.transientOf(key1, val1, key2, val2, key3, val3, + final io.usethesource.capsule.Map.Transient tmp = io.usethesource.capsule.Map. + Transient.of(key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6); return tmp.freeze(); } - public static ImmutableMap mapOf(Map map) { - if (map instanceof ImmutableMap) { - return (ImmutableMap) map; + public static io.usethesource.capsule.Map.Immutable mapOf(Map map) { + if (map instanceof io.usethesource.capsule.Map.Immutable) { + return (io.usethesource.capsule.Map.Immutable) map; } else { - final TransientMap tmp = DefaultTrieMap.transientOf(); + final io.usethesource.capsule.Map.Transient tmp = io.usethesource.capsule.Map. + Transient.of(); tmp.__putAll(map); return tmp.freeze(); } @@ -99,7 +115,6 @@ public boolean equals(Object other) { if (other instanceof Map) { try { - @SuppressWarnings("unchecked") Map that = (Map) other; if (this.size() == that.size()) { @@ -132,8 +147,9 @@ public Iterator> entryIterator() { } @Override - public ImmutableMap __putAll(Map map) { - TransientMap tmp = asTransient(); + public io.usethesource.capsule.Map.Immutable __putAll( + Map map) { + io.usethesource.capsule.Map.Transient tmp = asTransient(); if (tmp.__putAll(map)) { return tmp.freeze(); } else { @@ -142,9 +158,10 @@ public ImmutableMap __putAll(Map map) { } @Override - public ImmutableMap __putAllEquivalent(Map map, + public io.usethesource.capsule.Map.Immutable __putAllEquivalent( + Map map, Comparator cmp) { - TransientMap tmp = asTransient(); + io.usethesource.capsule.Map.Transient tmp = asTransient(); if (tmp.__putAllEquivalent(map, cmp)) { return tmp.freeze(); } else { @@ -189,6 +206,28 @@ public V setValue(V value) { throw new UnsupportedOperationException(); } + @Override + public int hashCode() { + return Objects.hashCode(key1) ^ Objects.hashCode(val1); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MapEntry mapEntry = (MapEntry) o; + return Objects.equals(key1, mapEntry.key1) && Objects.equals(val1, mapEntry.val1); + } + + @Override + public String toString() { + return String.format("<%s, %s>", key1, val1); + } + } @@ -254,28 +293,30 @@ public SupplierIterator keyIterator() { } @Override - public ImmutableMap __put(K key, V val) { + public io.usethesource.capsule.Map.Immutable __put(K key, V val) { return mapOf(key, val); } @Override - public ImmutableMap __putEquivalent(K key, V val, Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __putEquivalent(K key, V val, + Comparator cmp) { return mapOf(key, val); } @Override - public ImmutableMap __remove(K key) { + public io.usethesource.capsule.Map.Immutable __remove(K key) { return this; } @Override - public ImmutableMap __removeEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __removeEquivalent(K key, + Comparator cmp) { return this; } @Override - public TransientMap asTransient() { - return DefaultTrieMap.transientOf(); + public io.usethesource.capsule.Map.Transient asTransient() { + return io.usethesource.capsule.Map.Transient.of(); } @Override @@ -421,7 +462,7 @@ public void remove() { } @Override - public ImmutableMap __put(K key, V val) { + public io.usethesource.capsule.Map.Immutable __put(K key, V val) { if (key.equals(key1)) { return mapOf(key, val); } else { @@ -430,7 +471,8 @@ public ImmutableMap __put(K key, V val) { } @Override - public ImmutableMap __putEquivalent(K key, V val, Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __putEquivalent(K key, V val, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return mapOf(key, val); } else { @@ -439,7 +481,7 @@ public ImmutableMap __putEquivalent(K key, V val, Comparator cmp) } @Override - public ImmutableMap __remove(K key) { + public io.usethesource.capsule.Map.Immutable __remove(K key) { if (key.equals(key1)) { return mapOf(); } else { @@ -448,7 +490,8 @@ public ImmutableMap __remove(K key) { } @Override - public ImmutableMap __removeEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __removeEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return mapOf(); } else { @@ -457,8 +500,8 @@ public ImmutableMap __removeEquivalent(K key, Comparator cmp) { } @Override - public TransientMap asTransient() { - return DefaultTrieMap.transientOf(key1, val1); + public io.usethesource.capsule.Map.Transient asTransient() { + return io.usethesource.capsule.Map.Transient.of(key1, val1); } @Override @@ -632,7 +675,7 @@ public void remove() { } @Override - public ImmutableMap __put(K key, V val) { + public io.usethesource.capsule.Map.Immutable __put(K key, V val) { if (key.equals(key1)) { return mapOf(key, val, key2, val2); } else if (key.equals(key2)) { @@ -643,7 +686,8 @@ public ImmutableMap __put(K key, V val) { } @Override - public ImmutableMap __putEquivalent(K key, V val, Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __putEquivalent(K key, V val, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return mapOf(key, val, key2, val2); } else if (cmp.compare(key, key2) == 0) { @@ -654,7 +698,7 @@ public ImmutableMap __putEquivalent(K key, V val, Comparator cmp) } @Override - public ImmutableMap __remove(K key) { + public io.usethesource.capsule.Map.Immutable __remove(K key) { if (key.equals(key1)) { return mapOf(key2, val2); } else if (key.equals(key2)) { @@ -665,7 +709,8 @@ public ImmutableMap __remove(K key) { } @Override - public ImmutableMap __removeEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __removeEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return mapOf(key2, val2); } else if (cmp.compare(key, key2) == 0) { @@ -676,8 +721,8 @@ public ImmutableMap __removeEquivalent(K key, Comparator cmp) { } @Override - public TransientMap asTransient() { - return DefaultTrieMap.transientOf(key1, val1, key2, val2); + public io.usethesource.capsule.Map.Transient asTransient() { + return io.usethesource.capsule.Map.Transient.of(key1, val1, key2, val2); } @Override @@ -874,7 +919,7 @@ public void remove() { } @Override - public ImmutableMap __put(K key, V val) { + public io.usethesource.capsule.Map.Immutable __put(K key, V val) { if (key.equals(key1)) { return mapOf(key, val, key2, val2, key3, val3); } else if (key.equals(key2)) { @@ -887,7 +932,8 @@ public ImmutableMap __put(K key, V val) { } @Override - public ImmutableMap __putEquivalent(K key, V val, Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __putEquivalent(K key, V val, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return mapOf(key, val, key2, val2, key3, val3); } else if (cmp.compare(key, key2) == 0) { @@ -900,7 +946,7 @@ public ImmutableMap __putEquivalent(K key, V val, Comparator cmp) } @Override - public ImmutableMap __remove(K key) { + public io.usethesource.capsule.Map.Immutable __remove(K key) { if (key.equals(key1)) { return mapOf(key2, val2, key3, val3); } else if (key.equals(key2)) { @@ -913,7 +959,8 @@ public ImmutableMap __remove(K key) { } @Override - public ImmutableMap __removeEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __removeEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return mapOf(key2, val2, key3, val3); } else if (cmp.compare(key, key2) == 0) { @@ -926,8 +973,8 @@ public ImmutableMap __removeEquivalent(K key, Comparator cmp) { } @Override - public TransientMap asTransient() { - return DefaultTrieMap.transientOf(key1, val1, key2, val2, key3, val3); + public io.usethesource.capsule.Map.Transient asTransient() { + return io.usethesource.capsule.Map.Transient.of(key1, val1, key2, val2, key3, val3); } @Override @@ -1149,7 +1196,7 @@ public void remove() { } @Override - public ImmutableMap __put(K key, V val) { + public io.usethesource.capsule.Map.Immutable __put(K key, V val) { if (key.equals(key1)) { return mapOf(key, val, key2, val2, key3, val3, key4, val4); } else if (key.equals(key2)) { @@ -1164,7 +1211,8 @@ public ImmutableMap __put(K key, V val) { } @Override - public ImmutableMap __putEquivalent(K key, V val, Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __putEquivalent(K key, V val, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return mapOf(key, val, key2, val2, key3, val3, key4, val4); } else if (cmp.compare(key, key2) == 0) { @@ -1179,7 +1227,7 @@ public ImmutableMap __putEquivalent(K key, V val, Comparator cmp) } @Override - public ImmutableMap __remove(K key) { + public io.usethesource.capsule.Map.Immutable __remove(K key) { if (key.equals(key1)) { return mapOf(key2, val2, key3, val3, key4, val4); } else if (key.equals(key2)) { @@ -1194,7 +1242,8 @@ public ImmutableMap __remove(K key) { } @Override - public ImmutableMap __removeEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __removeEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return mapOf(key2, val2, key3, val3, key4, val4); } else if (cmp.compare(key, key2) == 0) { @@ -1209,8 +1258,9 @@ public ImmutableMap __removeEquivalent(K key, Comparator cmp) { } @Override - public TransientMap asTransient() { - return DefaultTrieMap.transientOf(key1, val1, key2, val2, key3, val3, key4, val4); + public io.usethesource.capsule.Map.Transient asTransient() { + return io.usethesource.capsule.Map. + Transient.of(key1, val1, key2, val2, key3, val3, key4, val4); } @Override @@ -1457,7 +1507,7 @@ public void remove() { } @Override - public ImmutableMap __put(K key, V val) { + public io.usethesource.capsule.Map.Immutable __put(K key, V val) { if (key.equals(key1)) { return mapOf(key, val, key2, val2, key3, val3, key4, val4, key5, val5); } else if (key.equals(key2)) { @@ -1474,7 +1524,8 @@ public ImmutableMap __put(K key, V val) { } @Override - public ImmutableMap __putEquivalent(K key, V val, Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __putEquivalent(K key, V val, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return mapOf(key, val, key2, val2, key3, val3, key4, val4, key5, val5); } else if (cmp.compare(key, key2) == 0) { @@ -1491,7 +1542,7 @@ public ImmutableMap __putEquivalent(K key, V val, Comparator cmp) } @Override - public ImmutableMap __remove(K key) { + public io.usethesource.capsule.Map.Immutable __remove(K key) { if (key.equals(key1)) { return mapOf(key2, val2, key3, val3, key4, val4, key5, val5); } else if (key.equals(key2)) { @@ -1508,7 +1559,8 @@ public ImmutableMap __remove(K key) { } @Override - public ImmutableMap __removeEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __removeEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return mapOf(key2, val2, key3, val3, key4, val4, key5, val5); } else if (cmp.compare(key, key2) == 0) { @@ -1525,8 +1577,9 @@ public ImmutableMap __removeEquivalent(K key, Comparator cmp) { } @Override - public TransientMap asTransient() { - return DefaultTrieMap.transientOf(key1, val1, key2, val2, key3, val3, key4, val4, key5, val5); + public io.usethesource.capsule.Map.Transient asTransient() { + return io.usethesource.capsule.Map. + Transient.of(key1, val1, key2, val2, key3, val3, key4, val4, key5, val5); } @Override diff --git a/src/main/java/io/usethesource/capsule/AbstractSpecialisedImmutableSet.java b/capsule-core/src/main/java/io/usethesource/capsule/util/collection/AbstractSpecialisedImmutableSet.java similarity index 82% rename from src/main/java/io/usethesource/capsule/AbstractSpecialisedImmutableSet.java rename to capsule-core/src/main/java/io/usethesource/capsule/util/collection/AbstractSpecialisedImmutableSet.java index daba829..eb8dd47 100644 --- a/src/main/java/io/usethesource/capsule/AbstractSpecialisedImmutableSet.java +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/collection/AbstractSpecialisedImmutableSet.java @@ -5,7 +5,7 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; +package io.usethesource.capsule.util.collection; import java.util.Collection; import java.util.Comparator; @@ -14,48 +14,54 @@ import java.util.Objects; import java.util.Set; +import io.usethesource.capsule.util.iterator.EmptySupplierIterator; +import io.usethesource.capsule.util.iterator.SupplierIterator; + public abstract class AbstractSpecialisedImmutableSet extends AbstractImmutableSet - implements ImmutableSet, Cloneable { + implements io.usethesource.capsule.Set.Immutable, Cloneable { - @SuppressWarnings("rawtypes") - private static ImmutableSet EMPTY_SET = new Set0(); + private static io.usethesource.capsule.Set.Immutable EMPTY_SET = new Set0(); - @SuppressWarnings("unchecked") - public static ImmutableSet setOf() { + public static io.usethesource.capsule.Set.Immutable setOf() { return EMPTY_SET; } - public static ImmutableSet setOf(K key1) { + public static io.usethesource.capsule.Set.Immutable setOf(K key1) { return new Set1(key1); } - public static ImmutableSet setOf(K key1, K key2) { + public static io.usethesource.capsule.Set.Immutable setOf(K key1, K key2) { return new Set2(key1, key2); } - public static ImmutableSet setOf(K key1, K key2, K key3) { + public static io.usethesource.capsule.Set.Immutable setOf(K key1, K key2, K key3) { return new Set3(key1, key2, key3); } - public static ImmutableSet setOf(K key1, K key2, K key3, K key4) { + public static io.usethesource.capsule.Set.Immutable setOf(K key1, K key2, K key3, + K key4) { return new Set4(key1, key2, key3, key4); } - public static ImmutableSet setOf(K key1, K key2, K key3, K key4, K key5) { + public static io.usethesource.capsule.Set.Immutable setOf(K key1, K key2, K key3, + K key4, K key5) { return new Set5(key1, key2, key3, key4, key5); } - public static ImmutableSet setOf(K key1, K key2, K key3, K key4, K key5, K key6) { - final TransientSet tmp = DefaultTrieSet.transientOf(key1, key2, key3, key4, key5, key6); + public static io.usethesource.capsule.Set.Immutable setOf(K key1, K key2, K key3, + K key4, K key5, K key6) { + final io.usethesource.capsule.Set.Transient tmp = io.usethesource.capsule.Set.Transient + .of(key1, key2, key3, key4, key5, key6); return tmp.freeze(); } - public static ImmutableSet setOf(Set set) { + public static io.usethesource.capsule.Set.Immutable setOf(Set set) { if (set instanceof AbstractSpecialisedImmutableSet) { - return (ImmutableSet) set; + return (io.usethesource.capsule.Set.Immutable) set; } else { - final TransientSet tmp = DefaultTrieSet.transientOf(); - // TODO check interface definition of ImmutableSet.__insertAll() + final io.usethesource.capsule.Set.Transient tmp = io.usethesource.capsule.Set.Transient + .of(); + // TODO check interface definition of Immutable.union() for (K item : set) { tmp.__insert(item); } @@ -114,7 +120,6 @@ public boolean equals(Object other) { if (other instanceof Set) { try { - @SuppressWarnings("unchecked") Set that = (Set) other; if (this.size() == that.size()) { @@ -144,8 +149,8 @@ public boolean isTransientSupported() { } @Override - public ImmutableSet __insertAll(Set set) { - TransientSet tmp = asTransient(); + public io.usethesource.capsule.Set.Immutable __insertAll(Set set) { + io.usethesource.capsule.Set.Transient tmp = asTransient(); if (tmp.__insertAll(set)) { return tmp.freeze(); } else { @@ -154,8 +159,9 @@ public ImmutableSet __insertAll(Set set) { } @Override - public ImmutableSet __insertAllEquivalent(Set set, Comparator cmp) { - TransientSet tmp = asTransient(); + public io.usethesource.capsule.Set.Immutable __insertAllEquivalent(Set set, + Comparator cmp) { + io.usethesource.capsule.Set.Transient tmp = asTransient(); if (tmp.__insertAllEquivalent(set, cmp)) { return tmp.freeze(); } else { @@ -164,8 +170,8 @@ public ImmutableSet __insertAllEquivalent(Set set, Comparator __retainAll(Set set) { - TransientSet tmp = asTransient(); + public io.usethesource.capsule.Set.Immutable __retainAll(Set set) { + io.usethesource.capsule.Set.Transient tmp = asTransient(); if (tmp.__retainAll(set)) { return tmp.freeze(); } else { @@ -174,9 +180,10 @@ public ImmutableSet __retainAll(Set set) { } @Override - public ImmutableSet __retainAllEquivalent(TransientSet set, + public io.usethesource.capsule.Set.Immutable __retainAllEquivalent( + io.usethesource.capsule.Set.Transient set, Comparator cmp) { - TransientSet tmp = asTransient(); + io.usethesource.capsule.Set.Transient tmp = asTransient(); if (tmp.__retainAllEquivalent(set, cmp)) { return tmp.freeze(); } else { @@ -185,8 +192,8 @@ public ImmutableSet __retainAllEquivalent(TransientSet set, } @Override - public ImmutableSet __removeAll(Set set) { - TransientSet tmp = asTransient(); + public io.usethesource.capsule.Set.Immutable __removeAll(Set set) { + io.usethesource.capsule.Set.Transient tmp = asTransient(); if (tmp.__removeAll(set)) { return tmp.freeze(); } else { @@ -195,8 +202,9 @@ public ImmutableSet __removeAll(Set set) { } @Override - public ImmutableSet __removeAllEquivalent(Set set, Comparator cmp) { - TransientSet tmp = asTransient(); + public io.usethesource.capsule.Set.Immutable __removeAllEquivalent(Set set, + Comparator cmp) { + io.usethesource.capsule.Set.Transient tmp = asTransient(); if (tmp.__removeAllEquivalent(set, cmp)) { return tmp.freeze(); } else { @@ -243,28 +251,30 @@ public SupplierIterator keyIterator() { } @Override - public ImmutableSet __insert(K key) { + public io.usethesource.capsule.Set.Immutable __insert(K key) { return setOf(key); } @Override - public ImmutableSet __insertEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __insertEquivalent(K key, + Comparator cmp) { return setOf(key); } @Override - public ImmutableSet __remove(K key) { + public io.usethesource.capsule.Set.Immutable __remove(K key) { return this; } @Override - public ImmutableSet __removeEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __removeEquivalent(K key, + Comparator cmp) { return this; } @Override - public TransientSet asTransient() { - return DefaultTrieSet.transientOf(); + public io.usethesource.capsule.Set.Transient asTransient() { + return io.usethesource.capsule.Set.Transient.of(); } @Override @@ -375,7 +385,7 @@ public void remove() { } @Override - public ImmutableSet __insert(K key) { + public io.usethesource.capsule.Set.Immutable __insert(K key) { if (key.equals(key1)) { return setOf(key); } else { @@ -384,7 +394,8 @@ public ImmutableSet __insert(K key) { } @Override - public ImmutableSet __insertEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __insertEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return setOf(key); } else { @@ -393,7 +404,7 @@ public ImmutableSet __insertEquivalent(K key, Comparator cmp) { } @Override - public ImmutableSet __remove(K key) { + public io.usethesource.capsule.Set.Immutable __remove(K key) { if (key.equals(key1)) { return setOf(); } else { @@ -402,7 +413,8 @@ public ImmutableSet __remove(K key) { } @Override - public ImmutableSet __removeEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __removeEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return setOf(); } else { @@ -411,8 +423,8 @@ public ImmutableSet __removeEquivalent(K key, Comparator cmp) { } @Override - public TransientSet asTransient() { - return DefaultTrieSet.transientOf(key1); + public io.usethesource.capsule.Set.Transient asTransient() { + return io.usethesource.capsule.Set.Transient.of(key1); } @Override @@ -542,7 +554,7 @@ public void remove() { } @Override - public ImmutableSet __insert(K key) { + public io.usethesource.capsule.Set.Immutable __insert(K key) { if (key.equals(key1)) { return setOf(key, key2); } else if (key.equals(key2)) { @@ -553,7 +565,8 @@ public ImmutableSet __insert(K key) { } @Override - public ImmutableSet __insertEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __insertEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return setOf(key, key2); } else if (cmp.compare(key, key2) == 0) { @@ -564,7 +577,7 @@ public ImmutableSet __insertEquivalent(K key, Comparator cmp) { } @Override - public ImmutableSet __remove(K key) { + public io.usethesource.capsule.Set.Immutable __remove(K key) { if (key.equals(key1)) { return setOf(key2); } else if (key.equals(key2)) { @@ -575,7 +588,8 @@ public ImmutableSet __remove(K key) { } @Override - public ImmutableSet __removeEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __removeEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return setOf(key2); } else if (cmp.compare(key, key2) == 0) { @@ -586,8 +600,8 @@ public ImmutableSet __removeEquivalent(K key, Comparator cmp) { } @Override - public TransientSet asTransient() { - return DefaultTrieSet.transientOf(key1, key2); + public io.usethesource.capsule.Set.Transient asTransient() { + return io.usethesource.capsule.Set.Transient.of(key1, key2); } @Override @@ -732,7 +746,7 @@ public void remove() { } @Override - public ImmutableSet __insert(K key) { + public io.usethesource.capsule.Set.Immutable __insert(K key) { if (key.equals(key1)) { return setOf(key, key2, key3); } else if (key.equals(key2)) { @@ -745,7 +759,8 @@ public ImmutableSet __insert(K key) { } @Override - public ImmutableSet __insertEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __insertEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return setOf(key, key2, key3); } else if (cmp.compare(key, key2) == 0) { @@ -758,7 +773,7 @@ public ImmutableSet __insertEquivalent(K key, Comparator cmp) { } @Override - public ImmutableSet __remove(K key) { + public io.usethesource.capsule.Set.Immutable __remove(K key) { if (key.equals(key1)) { return setOf(key2, key3); } else if (key.equals(key2)) { @@ -771,7 +786,8 @@ public ImmutableSet __remove(K key) { } @Override - public ImmutableSet __removeEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __removeEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return setOf(key2, key3); } else if (cmp.compare(key, key2) == 0) { @@ -784,8 +800,8 @@ public ImmutableSet __removeEquivalent(K key, Comparator cmp) { } @Override - public TransientSet asTransient() { - return DefaultTrieSet.transientOf(key1, key2, key3); + public io.usethesource.capsule.Set.Transient asTransient() { + return io.usethesource.capsule.Set.Transient.of(key1, key2, key3); } @Override @@ -946,7 +962,7 @@ public void remove() { } @Override - public ImmutableSet __insert(K key) { + public io.usethesource.capsule.Set.Immutable __insert(K key) { if (key.equals(key1)) { return setOf(key, key2, key3, key4); } else if (key.equals(key2)) { @@ -961,7 +977,8 @@ public ImmutableSet __insert(K key) { } @Override - public ImmutableSet __insertEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __insertEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return setOf(key, key2, key3, key4); } else if (cmp.compare(key, key2) == 0) { @@ -976,7 +993,7 @@ public ImmutableSet __insertEquivalent(K key, Comparator cmp) { } @Override - public ImmutableSet __remove(K key) { + public io.usethesource.capsule.Set.Immutable __remove(K key) { if (key.equals(key1)) { return setOf(key2, key3, key4); } else if (key.equals(key2)) { @@ -991,7 +1008,8 @@ public ImmutableSet __remove(K key) { } @Override - public ImmutableSet __removeEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __removeEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return setOf(key2, key3, key4); } else if (cmp.compare(key, key2) == 0) { @@ -1006,8 +1024,8 @@ public ImmutableSet __removeEquivalent(K key, Comparator cmp) { } @Override - public TransientSet asTransient() { - return DefaultTrieSet.transientOf(key1, key2, key3, key4); + public io.usethesource.capsule.Set.Transient asTransient() { + return io.usethesource.capsule.Set.Transient.of(key1, key2, key3, key4); } @Override @@ -1185,7 +1203,7 @@ public void remove() { } @Override - public ImmutableSet __insert(K key) { + public io.usethesource.capsule.Set.Immutable __insert(K key) { if (key.equals(key1)) { return setOf(key, key2, key3, key4, key5); } else if (key.equals(key2)) { @@ -1202,7 +1220,8 @@ public ImmutableSet __insert(K key) { } @Override - public ImmutableSet __insertEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __insertEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return setOf(key, key2, key3, key4, key5); } else if (cmp.compare(key, key2) == 0) { @@ -1219,7 +1238,7 @@ public ImmutableSet __insertEquivalent(K key, Comparator cmp) { } @Override - public ImmutableSet __remove(K key) { + public io.usethesource.capsule.Set.Immutable __remove(K key) { if (key.equals(key1)) { return setOf(key2, key3, key4, key5); } else if (key.equals(key2)) { @@ -1236,7 +1255,8 @@ public ImmutableSet __remove(K key) { } @Override - public ImmutableSet __removeEquivalent(K key, Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __removeEquivalent(K key, + Comparator cmp) { if (cmp.compare(key, key1) == 0) { return setOf(key2, key3, key4, key5); } else if (cmp.compare(key, key2) == 0) { @@ -1253,8 +1273,8 @@ public ImmutableSet __removeEquivalent(K key, Comparator cmp) { } @Override - public TransientSet asTransient() { - return DefaultTrieSet.transientOf(key1, key2, key3, key4, key5); + public io.usethesource.capsule.Set.Transient asTransient() { + return io.usethesource.capsule.Set.Transient.of(key1, key2, key3, key4, key5); } @Override diff --git a/src/main/java/io/usethesource/capsule/ArrayIterator.java b/capsule-core/src/main/java/io/usethesource/capsule/util/iterator/ArrayIterator.java similarity index 96% rename from src/main/java/io/usethesource/capsule/ArrayIterator.java rename to capsule-core/src/main/java/io/usethesource/capsule/util/iterator/ArrayIterator.java index f497df0..4c05a10 100644 --- a/src/main/java/io/usethesource/capsule/ArrayIterator.java +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/iterator/ArrayIterator.java @@ -5,7 +5,7 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; +package io.usethesource.capsule.util.iterator; import java.util.Iterator; import java.util.NoSuchElementException; diff --git a/src/main/java/io/usethesource/capsule/ArrayKeyValueSupplierIterator.java b/capsule-core/src/main/java/io/usethesource/capsule/util/iterator/ArrayKeyValueSupplierIterator.java similarity index 95% rename from src/main/java/io/usethesource/capsule/ArrayKeyValueSupplierIterator.java rename to capsule-core/src/main/java/io/usethesource/capsule/util/iterator/ArrayKeyValueSupplierIterator.java index 83a5d15..8b3b975 100644 --- a/src/main/java/io/usethesource/capsule/ArrayKeyValueSupplierIterator.java +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/iterator/ArrayKeyValueSupplierIterator.java @@ -5,7 +5,7 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; +package io.usethesource.capsule.util.iterator; import java.util.NoSuchElementException; @@ -30,7 +30,6 @@ public boolean hasNext() { return currentIndex < end; } - @SuppressWarnings("unchecked") @Override public K next() { if (!hasNext()) { diff --git a/src/main/java/io/usethesource/capsule/ArraySupplierIterator.java b/capsule-core/src/main/java/io/usethesource/capsule/util/iterator/ArraySupplierIterator.java similarity index 95% rename from src/main/java/io/usethesource/capsule/ArraySupplierIterator.java rename to capsule-core/src/main/java/io/usethesource/capsule/util/iterator/ArraySupplierIterator.java index 9279306..22f6e75 100644 --- a/src/main/java/io/usethesource/capsule/ArraySupplierIterator.java +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/iterator/ArraySupplierIterator.java @@ -5,7 +5,7 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; +package io.usethesource.capsule.util.iterator; import java.util.NoSuchElementException; @@ -29,7 +29,6 @@ public boolean hasNext() { return currentIndex < end; } - @SuppressWarnings("unchecked") @Override public E next() { if (!hasNext()) { diff --git a/src/main/java/io/usethesource/capsule/EmptySupplierIterator.java b/capsule-core/src/main/java/io/usethesource/capsule/util/iterator/EmptySupplierIterator.java similarity index 90% rename from src/main/java/io/usethesource/capsule/EmptySupplierIterator.java rename to capsule-core/src/main/java/io/usethesource/capsule/util/iterator/EmptySupplierIterator.java index 5ce7fb6..57c2fdf 100644 --- a/src/main/java/io/usethesource/capsule/EmptySupplierIterator.java +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/iterator/EmptySupplierIterator.java @@ -5,16 +5,14 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; +package io.usethesource.capsule.util.iterator; import java.util.NoSuchElementException; public class EmptySupplierIterator implements SupplierIterator { - @SuppressWarnings("rawtypes") private static final SupplierIterator EMPTY_ITERATOR = new EmptySupplierIterator(); - @SuppressWarnings("unchecked") public static SupplierIterator emptyIterator() { return EMPTY_ITERATOR; } diff --git a/src/main/java/io/usethesource/capsule/SupplierIterator.java b/capsule-core/src/main/java/io/usethesource/capsule/util/iterator/SupplierIterator.java similarity index 82% rename from src/main/java/io/usethesource/capsule/SupplierIterator.java rename to capsule-core/src/main/java/io/usethesource/capsule/util/iterator/SupplierIterator.java index df359bf..ef4c6cd 100644 --- a/src/main/java/io/usethesource/capsule/SupplierIterator.java +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/iterator/SupplierIterator.java @@ -5,9 +5,11 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; +package io.usethesource.capsule.util.iterator; import java.util.Iterator; +import java.util.function.Supplier; public interface SupplierIterator extends Iterator, Supplier { + } diff --git a/capsule-core/src/main/java/io/usethesource/capsule/util/stream/CapsuleCollectors.java b/capsule-core/src/main/java/io/usethesource/capsule/util/stream/CapsuleCollectors.java new file mode 100644 index 0000000..e6f760d --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/stream/CapsuleCollectors.java @@ -0,0 +1,66 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.util.stream; + +import java.util.Collections; +import java.util.EnumSet; +import java.util.Set; +import java.util.function.BiConsumer; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collector; + +import io.usethesource.capsule.SetMultimap; + +public class CapsuleCollectors { + + public static final Set UNORDERED = + Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.UNORDERED)); + + public static Collector> toSet() { + return new DefaultCollector<>( + (Supplier>) io.usethesource.capsule.Set.Transient::of, + io.usethesource.capsule.Set.Transient::__insert, (left, right) -> { + left.__insertAll(right); + return left; + }, io.usethesource.capsule.Set.Transient::freeze, UNORDERED); + } + +// public static Collector> toMap( +// Function keyMapper, Function valueMapper) { +// +// /** extract key/value from type {@code T} and insert into multimap */ +// final BiConsumer, T> accumulator = +// (map, element) -> map.__put(keyMapper.apply(element), valueMapper.apply(element)); +// +// return new DefaultCollector<>( +// io.usethesource.capsule.Map::of, +// accumulator, +// (left, right) -> { +// left.union(right); +// return left; +// }, io.usethesource.capsule.Map.Transient::freeze, UNORDERED); +// } + + public static Collector> toSetMultimap( + Function keyMapper, Function valueMapper) { + + /** extract key/value from type {@code T} and insert into multimap */ + final BiConsumer, T> accumulator = + (map, element) -> map.__insert(keyMapper.apply(element), valueMapper.apply(element)); + + return new DefaultCollector<>( + SetMultimap.Transient::of, + accumulator, + (left, right) -> { + left.union(right); + return left; + }, SetMultimap.Transient::freeze, UNORDERED); + } + +} diff --git a/capsule-core/src/main/java/io/usethesource/capsule/util/stream/DefaultCollector.java b/capsule-core/src/main/java/io/usethesource/capsule/util/stream/DefaultCollector.java new file mode 100644 index 0000000..43c8d74 --- /dev/null +++ b/capsule-core/src/main/java/io/usethesource/capsule/util/stream/DefaultCollector.java @@ -0,0 +1,57 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.util.stream; + +import java.util.Set; +import java.util.function.BiConsumer; +import java.util.function.BinaryOperator; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collector; + +public class DefaultCollector implements Collector { + private final Supplier supplier; + private final BiConsumer accumulator; + private final BinaryOperator combiner; + private final Function finisher; + private final Set characteristics; + + public DefaultCollector(Supplier supplier, BiConsumer accumulator, + BinaryOperator combiner, Function finisher, Set characteristics) { + this.supplier = supplier; + this.accumulator = accumulator; + this.combiner = combiner; + this.finisher = finisher; + this.characteristics = characteristics; + } + + @Override + public BiConsumer accumulator() { + return accumulator; + } + + @Override + public Supplier supplier() { + return supplier; + } + + @Override + public BinaryOperator combiner() { + return combiner; + } + + @Override + public Function finisher() { + return finisher; + } + + @Override + public Set characteristics() { + return characteristics; + } +} diff --git a/capsule-experimental/capsule-experimental.iml b/capsule-experimental/capsule-experimental.iml new file mode 100644 index 0000000..d792b55 --- /dev/null +++ b/capsule-experimental/capsule-experimental.iml @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/capsule-experimental/pom.xml b/capsule-experimental/pom.xml new file mode 100644 index 0000000..5cdddf3 --- /dev/null +++ b/capsule-experimental/pom.xml @@ -0,0 +1,29 @@ + + 4.0.0 + + + io.usethesource + capsule-pom-parent + 0.3.0.HETEROGENEOUS-SNAPSHOT + + + io.usethesource + capsule-experimental + 0.3.0.HETEROGENEOUS-SNAPSHOT + jar + + + ${project.parent.basedir} + + + + + io.usethesource + capsule + 0.3.0.HETEROGENEOUS-SNAPSHOT + + + + diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/api/TernaryRelation.java b/capsule-experimental/src/main/java/io/usethesource/capsule/api/TernaryRelation.java new file mode 100644 index 0000000..580b371 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/api/TernaryRelation.java @@ -0,0 +1,37 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.api; + +import io.usethesource.capsule.Set; + +public interface TernaryRelation> extends Set { + + // TernaryRelation inverse(); + // + // SetMultimap toSetMultimap(); + + interface Immutable> + extends TernaryRelation, Set.Immutable { + + @Override + boolean isTransientSupported(); + + @Override + TernaryRelation.Transient asTransient(); + + } + + interface Transient> + extends TernaryRelation, Set.Transient { + + @Override + TernaryRelation.Immutable freeze(); + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/api/Triple.java b/capsule-experimental/src/main/java/io/usethesource/capsule/api/Triple.java new file mode 100644 index 0000000..f299a91 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/api/Triple.java @@ -0,0 +1,99 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.api; + +import java.util.Objects; + +public interface Triple { + + static Triple of(final T fst, final U snd, final V trd) { + return new ImmutableTriple( + Objects.requireNonNull(fst), + Objects.requireNonNull(snd), + Objects.requireNonNull(trd)); + } + + T _0(); + + U _1(); + + V _2(); + + T get(int columnIndex); + +} + + +class ImmutableTriple implements Triple { + + final T fst; + final U snd; + final V trd; + + public ImmutableTriple(final T fst, final U snd, final V trd) { + this.fst = fst; + this.snd = snd; + this.trd = trd; + } + + @Override + public T _0() { + return fst; + } + + @Override + public U _1() { + return snd; + } + + @Override + public V _2() { + return trd; + } + + @Override + public T1 get(int columnIndex) { + switch (columnIndex) { + case 0: + return (T1) fst; + case 1: + return (T1) snd; + case 2: + return (T1) trd; + default: + throw new IndexOutOfBoundsException(); + } + + } + + @Override + public int hashCode() { + return Objects.hash(fst, snd, trd); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + ImmutableTriple that = (ImmutableTriple) o; + + return Objects.equals(fst, that.fst) && Objects.equals(snd, that.snd) + && Objects.equals(trd, that.trd); + } + + @Override + public String toString() { + return String.format("<%s, %s, %s>", fst, snd, trd); + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/api/experimental/Map.java b/capsule-experimental/src/main/java/io/usethesource/capsule/api/experimental/Map.java new file mode 100644 index 0000000..a319e2a --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/api/experimental/Map.java @@ -0,0 +1,88 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.api.experimental; + +import java.util.Iterator; +import java.util.Optional; +import java.util.function.Function; + +import io.usethesource.capsule.util.iterator.SupplierIterator; + +public interface Map extends Iterable, Function> { + + long size(); + + boolean isEmpty(); + + boolean contains(final Object o); + + boolean containsValue(final Object o); + + // default boolean containsAll(final Set set) { + // for (K item : set) { + // if (!contains(item)) { + // return false; + // } + // } + // return true; + // + // } + + // K get(final Object o); + + @Override + SupplierIterator iterator(); + + // Iterator valueIterator(); + + // @Deprecated // TODO: replace with SupplierIterator interface + Iterator> entryIterator(); + + // @Deprecated // TODO: replace with SupplierIterator interface + // Set> entrySet(); + + /** + * The hash code of a map is order independent by combining the hashes of the elements (both keys + * and values) via a bitwise XOR operation. + * + * @return XOR reduction of all hashes of elements + */ + @Override + int hashCode(); + + @Override + boolean equals(Object other); + + Map.Immutable asImmutable(); + + interface Immutable extends Map { + + Map.Immutable insert(final K key, final V val); + + Map.Immutable remove(final K key); + + Map.Immutable insertAll(final Map map); + + boolean isTransientSupported(); + + Map.Transient asTransient(); + + java.util.Map asJdkCollection(); + } + + interface Transient extends Map { + + V insert(final K key, final V val); + + V remove(final K key); + + boolean insertAll(final Map map); + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/api/experimental/Set.java b/capsule-experimental/src/main/java/io/usethesource/capsule/api/experimental/Set.java new file mode 100644 index 0000000..62a11bb --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/api/experimental/Set.java @@ -0,0 +1,100 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.api.experimental; + +import java.util.Iterator; +import java.util.Optional; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.function.Function; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +public interface Set extends Iterable, Function> { + + long size(); + + boolean isEmpty(); + + boolean contains(final Object o); + + default boolean containsAll(final Set set) { + for (Object item : set) { + if (!contains(item)) { + return false; + } + } + return true; + } + + // K get(final Object o); + + @Override + Iterator iterator(); + + /** + * The hash code of a set is order independent by combining the hashes of the elements via a + * bitwise XOR operation. + * + * @return XOR reduction of all hashes of elements + */ + @Override + int hashCode(); + + @Override + boolean equals(Object other); + + default Spliterator spliterator() { + return Spliterators.spliterator(iterator(), size(), 0); + } + + default Stream stream() { + return StreamSupport.stream(spliterator(), false); + } + + default Stream parallelStream() { + return StreamSupport.stream(spliterator(), true); + } + + Set.Immutable asImmutable(); + + interface Immutable extends Set { + + Set.Immutable insert(final K key); + + Set.Immutable remove(final K key); + + Set.Immutable insertAll(final Set set); + + Set.Immutable removeAll(final Set set); + + Set.Immutable retainAll(final Set set); + + boolean isTransientSupported(); + + Set.Transient asTransient(); + + java.util.Set asJdkCollection(); + + } + + interface Transient extends Set { + + boolean insert(final K key); + + boolean remove(final K key); + + boolean insertAll(final Set set); + + boolean removeAll(final Set set); + + boolean retainAll(final Set set); + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/api/experimental/SetMultimap.java b/capsule-experimental/src/main/java/io/usethesource/capsule/api/experimental/SetMultimap.java new file mode 100644 index 0000000..9f7af37 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/api/experimental/SetMultimap.java @@ -0,0 +1,102 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.api.experimental; + +import java.util.Iterator; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; + +/* + * TODO: remove dependency of java.util.Map + */ +public interface SetMultimap + extends Iterable>, Function>> { + + long size(); + + // default int sizeDistinct() { + // return (int) entrySet().stream().map(Entry::getKey).distinct().count(); + // } + + boolean isEmpty(); + + boolean contains(final K key); + + boolean contains(final K key, V val); + + // boolean containsValue(final Object o); + + @Override + Iterator> iterator(); + + Iterator> nativeEntryIterator(); + + /** + * The hash code of a mult-imap is order independent by combining the hashes of the elements (both + * keys and values) via a bitwise XOR operation. + * + * @return XOR reduction of all hashes of elements + */ + @Override + int hashCode(); + + @Override + boolean equals(Object other); + + SetMultimap.Immutable asImmutable(); + + interface Immutable extends SetMultimap { + + SetMultimap.Immutable put(final K key, final V val); + + SetMultimap.Immutable put(final K key, final Set values); + + SetMultimap.Immutable insert(final K key, final V val); + + SetMultimap.Immutable insert(final K key, final Set values); + + SetMultimap.Immutable remove(final K key, final V val); + + SetMultimap.Immutable remove(final K key); + + SetMultimap.Immutable union(final SetMultimap setMultimap); + + SetMultimap.Immutable intersect(final SetMultimap setMultimap); + + SetMultimap.Immutable complement(final SetMultimap setMultimap); + + boolean isTransientSupported(); + + SetMultimap.Transient asTransient(); + + } + + interface Transient extends SetMultimap { + + boolean put(final K key, final V val); // TODO: return Set instead of boolean? + + boolean put(final K key, final Set values); // TODO: return Set instead of boolean? + + boolean insert(final K key, final V val); + + boolean insert(final K key, final Set values); + + boolean remove(final K key, final V val); + + boolean remove(final K key); + + boolean union(final SetMultimap setMultimap); + + boolean intersect(final SetMultimap setMultimap); + + boolean complement(final SetMultimap setMultimap); + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/core/converter/SetToLegacySetConverter.java b/capsule-experimental/src/main/java/io/usethesource/capsule/core/converter/SetToLegacySetConverter.java new file mode 100644 index 0000000..1ecf428 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/core/converter/SetToLegacySetConverter.java @@ -0,0 +1,157 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.core.converter; + +import java.util.Collection; +import java.util.Iterator; +import java.util.Spliterator; +import java.util.function.Consumer; +import java.util.stream.Stream; + +import io.usethesource.capsule.api.experimental.Set; +import io.usethesource.capsule.util.collection.AbstractImmutableSet; + +public class SetToLegacySetConverter extends AbstractImmutableSet implements io.usethesource.capsule.Set.Immutable { + + private final Set.Immutable immutableSet; + + private SetToLegacySetConverter(final Set.Immutable immutableSet) { + this.immutableSet = immutableSet; + } + + public static final io.usethesource.capsule.Set.Immutable adapt(final Set.Immutable immutableSet) { + return new SetToLegacySetConverter(immutableSet); + } + + @Override + public boolean containsAll(Collection collection) { + if (collection instanceof Set) { + final Set set = (Set) collection; + return immutableSet.containsAll(set); + } else { + return collection.stream().allMatch(immutableSet::contains); + } + } + + @Override + public K get(Object o) { + return (K) immutableSet.apply((K) o); + } + + @Override + public io.usethesource.capsule.Set.Immutable __insert(K key) { + return adapt(immutableSet.insert(key)); + } + + @Override + public io.usethesource.capsule.Set.Immutable __insertAll(java.util.Set set) { + final Set.Transient tmp = immutableSet.asTransient(); + set.forEach(tmp::insert); + return adapt(tmp.asImmutable()); + } + + @Override + public io.usethesource.capsule.Set.Immutable __remove(K key) { + return adapt(immutableSet.remove(key)); + } + + @Override + public io.usethesource.capsule.Set.Immutable __removeAll(java.util.Set set) { + final Set.Transient tmp = immutableSet.asTransient(); + set.forEach(tmp::remove); + return adapt(tmp.asImmutable()); + } + + @Override + public io.usethesource.capsule.Set.Immutable __retainAll(java.util.Set set) { + throw new UnsupportedOperationException("Not yet implemented."); + } + + @Override + public Iterator keyIterator() { + return immutableSet.iterator(); + } + + @Override + public boolean isTransientSupported() { + return false; + } + + @Override + public io.usethesource.capsule.Set.Transient asTransient() { + return null; + } + + @Override + public int size() { + return Math.toIntExact(immutableSet.size()); + } + + @Override + public boolean isEmpty() { + return immutableSet.isEmpty(); + } + + @Override + public boolean contains(Object o) { + return immutableSet.contains(o); + } + + @Override + public Iterator iterator() { + return immutableSet.iterator(); + } + + @Override + public Object[] toArray() { + return immutableSet.stream().toArray(); + } + + @Override + public T[] toArray(T[] a) { + return immutableSet.stream().toArray( + size -> (T[]) java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size)); + } + + @Override + public int hashCode() { + return stream().mapToInt(K::hashCode).sum(); + } + + @Override + public boolean equals(Object other) { + /** + * NOTE: different semantic between Immutable and Set.Immutable (the former + * {@link #equals(Object) with {@link java.util.Set}, the latter does not). + */ + // return immutableSet.equals(other); + + throw new UnsupportedOperationException("Unsupported difference in semantics."); + } + + @Override + public Spliterator spliterator() { + return immutableSet.spliterator(); + } + + @Override + public Stream stream() { + return immutableSet.stream(); + } + + @Override + public Stream parallelStream() { + return immutableSet.parallelStream(); + } + + @Override + public void forEach(Consumer action) { + immutableSet.forEach(action); + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/core/experimental/TrieMap.java b/capsule-experimental/src/main/java/io/usethesource/capsule/core/experimental/TrieMap.java new file mode 100644 index 0000000..9d0dbfc --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/core/experimental/TrieMap.java @@ -0,0 +1,2631 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.core.experimental; + +import java.text.DecimalFormat; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Optional; +import java.util.concurrent.atomic.AtomicReference; + +import io.usethesource.capsule.api.experimental.Map; +import io.usethesource.capsule.util.ArrayUtils; +import io.usethesource.capsule.util.iterator.SupplierIterator; + +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +/* + * TODO: fix hash code implementation + */ +public class TrieMap implements Map.Immutable { + + private static final TrieMap EMPTY_MAP = new TrieMap(CompactMapNode.EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractMapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieMap(AbstractMapNode rootNode, int hashCode, int cachedSize) { + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final Map.Immutable of() { + return TrieMap.EMPTY_MAP; + } + + public static final Map.Immutable of(Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + Map.Immutable result = TrieMap.EMPTY_MAP; + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final K key = (K) keyValuePairs[i]; + final V val = (V) keyValuePairs[i + 1]; + + result = result.insert(key, val); + } + + return result; + } + + public static final Map.Transient transientOf() { + return TrieMap.EMPTY_MAP.asTransient(); + } + + public static final Map.Transient transientOf(Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + final Map.Transient result = TrieMap.EMPTY_MAP.asTransient(); + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final K key = (K) keyValuePairs[i]; + final V val = (V) keyValuePairs[i + 1]; + + result.insert(key, val); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final java.util.Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean contains(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + @Override + public Optional apply(K key) { + return rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + } + + public V get(final Object o) { + try { + final K key = (K) o; + return apply(key).orElse(null); + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public Map.Immutable insert(final K key, final V val) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieMap(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val.hashCode(); + return new TrieMap(newRootNode, hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + @Override + public Map.Immutable insertAll(final Map map) { + final Map.Transient tmpTransient = this.asTransient(); + tmpTransient.insertAll(map); + return tmpTransient.asImmutable(); + } + + @Override + public Map.Immutable remove(final K key) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieMap(newRootNode, hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + @Override + public long size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public SupplierIterator iterator() { + return new MapSupplierIterator<>(rootNode); + } + + public Iterator keyIterator() { + return new MapKeyIterator<>(rootNode); + } + + public Iterator valueIterator() { + return new MapValueIterator<>(rootNode); + } + + @Override + public Iterator> entryIterator() { + return new MapEntryIterator<>(rootNode); + } + + // @Override + // public Set keySet() { + // Set keySet = null; + // + // if (keySet == null) { + // keySet = new AbstractSet() { + // @Override + // public Iterator iterator() { + // return TrieMap.this.keyIterator(); + // } + // + // @Override + // public int size() { + // return TrieMap.this.size(); + // } + // + // @Override + // public boolean isEmpty() { + // return TrieMap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // TrieMap.this.clear(); + // } + // + // @Override + // public boolean contains(Object k) { + // return TrieMap.this.contains(k); + // } + // }; + // } + // + // return keySet; + // } + // + // @Override + // public Collection values() { + // Collection values = null; + // + // if (values == null) { + // values = new AbstractCollection() { + // @Override + // public Iterator iterator() { + // return TrieMap.this.valueIterator(); + // } + // + // @Override + // public int size() { + // return TrieMap.this.size(); + // } + // + // @Override + // public boolean isEmpty() { + // return TrieMap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // TrieMap.this.clear(); + // } + // + // @Override + // public boolean contains(Object v) { + // return TrieMap.this.containsValue(v); + // } + // }; + // } + // + // return values; + // } + // + // @Override + // public Set> entrySet() { + // Set> entrySet = null; + // + // if (entrySet == null) { + // entrySet = new AbstractSet>() { + // @Override + // public Iterator> iterator() { + // return new Iterator>() { + // private final Iterator> i = entryIterator(); + // + // @Override + // public boolean hasNext() { + // return i.hasNext(); + // } + // + // @Override + // public java.util.Map.Entry next() { + // return i.next(); + // } + // + // @Override + // public void remove() { + // i.remove(); + // } + // }; + // } + // + // @Override + // public int size() { + // return TrieMap.this.size(); + // } + // + // @Override + // public boolean isEmpty() { + // return TrieMap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // TrieMap.this.clear(); + // } + // + // @Override + // public boolean contains(Object k) { + // return TrieMap.this.contains(k); + // } + // }; + // } + // + // return entrySet; + // } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieMap) { + TrieMap that = (TrieMap) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entryIterator(); it.hasNext(); ) { + java.util.Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + final V val = (V) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public java.util.Map asJdkCollection() { + return new TrieMapAsImmutableJdkCollection<>(this); + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public Map.Transient asTransient() { + return new TransientTrieMap(this); + } + + @Override + public Map.Immutable asImmutable() { + return this; + } + + /* + * For analysis purposes only. + */ + protected AbstractMapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieMapNodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. Payload X Node + */ + protected int[][] arityCombinationsHistogram() { + final Iterator> it = nodeIterator(); + final int[][] sumArityCombinations = new int[33][33]; + + while (it.hasNext()) { + final AbstractMapNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[33]; + + final int maxArity = 32; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[33]; + for (int cumsum = 0, i = 0; i < 33; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 33; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + static final class MapResult { + + private V replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(V replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static MapResult unchanged() { + return new MapResult<>(); + } + + private MapResult() { + } + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public V getReplacedValue() { + return replacedValue; + } + } + + protected static interface INode { + + } + + protected static abstract class AbstractMapNode implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final K key, final int keyHash, final int shift); + + abstract boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final K key, final int keyHash, final int shift); + + abstract Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract CompactMapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + abstract CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractMapNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractMapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractMapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract K getKey(final int index); + + abstract V getValue(final int index); + + abstract java.util.Map.Entry getKeyValueEntry(final int index); + + @Deprecated + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + int size() { + final Iterator it = new MapKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactMapNode extends AbstractMapNode { + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + abstract int nodeMap(); + + abstract int dataMap(); + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactMapNode getNode(final int index); + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactMapNode copyAndSetValue(final AtomicReference mutator, + final int bitpos, final V val); + + abstract CompactMapNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final K key, final V val); + + abstract CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos); + + abstract CompactMapNode copyAndSetNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromInlineToNode( + final AtomicReference mutator, final int bitpos, final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromNodeToInline( + final AtomicReference mutator, final int bitpos, final CompactMapNode node); + + static final CompactMapNode mergeTwoKeyValPairs(final K key0, final V val0, + final int keyHash0, final K key1, final V val1, final int keyHash1, final int shift) { + assert !(key0.equals(key1)); + + if (shift >= HASH_CODE_LENGTH) { + return new HashCollisionMapNode<>(keyHash0, (K[]) new Object[]{key0, key1}, + (V[]) new Object[]{val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int dataMap = bitpos(mask0) | bitpos(mask1); + + if (mask0 < mask1) { + return nodeOf(null, (0), dataMap, new Object[]{key0, val0, key1, val1}); + } else { + return nodeOf(null, (0), dataMap, new Object[]{key1, val1, key0, val0}); + } + } else { + final CompactMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, + keyHash1, shift + BIT_PARTITION_SIZE); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf(null, nodeMap, (0), new Object[]{node}); + } + } + + static final CompactMapNode EMPTY_NODE; + + static { + + EMPTY_NODE = new BitmapIndexedMapNode<>(null, (0), (0), new Object[]{}); + + } + + ; + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object[] nodes) { + return new BitmapIndexedMapNode<>(mutator, nodeMap, dataMap, nodes); + } + + static final CompactMapNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactMapNode nodeOf(AtomicReference mutator, + final int nodeMap, final int dataMap, final K key, final V val) { + assert nodeMap == 0; + return nodeOf(mutator, (0), dataMap, new Object[]{key, val}); + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + CompactMapNode nodeAt(final int bitpos) { + return getNode(nodeIndex(bitpos)); + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index).equals(key); + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return false; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return cmp.compare(getKey(index), key) == 0; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index).equals(key)) { + final V result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (cmp.compare(getKey(index), key) == 0) { + final V result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return Optional.empty(); + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (currentKey.equals(key)) { + final V currentVal = getValue(dataIndex); + + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } else { + final V currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (cmp.compare(currentKey, key) == 0) { + final V currentVal = getValue(dataIndex); + + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } else { + final V currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex).equals(key)) { + final V currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(1), getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(0), getValue(0)); + } + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (this.payloadArity() == 0 && this.nodeArity() == 1) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (cmp.compare(getKey(dataIndex), key) == 0) { + final V currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(1), getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(0), getValue(0)); + } + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (this.payloadArity() == 0 && this.nodeArity() == 1) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getKey(i)), + Objects.hashCode(getValue(i)))); + + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedMapNode extends CompactMapNode { + + private final int nodeMap; + private final int dataMap; + + CompactMixedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + private static final class BitmapIndexedMapNode extends CompactMixedMapNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + super(mutator, nodeMap, dataMap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + + assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < TUPLE_LENGTH * payloadArity(); i++) { + assert ((nodes[i] instanceof CompactMapNode) == false); + } + for (int i = TUPLE_LENGTH * payloadArity(); i < nodes.length; i++) { + assert ((nodes[i] instanceof CompactMapNode) == true); + } + } + + assert nodeInvariant(); + } + + @Override + K getKey(final int index) { + return (K) nodes[TUPLE_LENGTH * index]; + } + + @Override + V getValue(final int index) { + return (V) nodes[TUPLE_LENGTH * index + 1]; + } + + @Override + java.util.Map.Entry getKeyValueEntry(final int index) { + return entryOf((K) nodes[TUPLE_LENGTH * index], (V) nodes[TUPLE_LENGTH * index + 1]); + } + + @Override + CompactMapNode getNode(final int index) { + return (CompactMapNode) nodes[nodes.length - 1 - index]; + } + + @Override + boolean hasPayload() { + return dataMap() != 0; + } + + @Override + int payloadArity() { + return java.lang.Integer.bitCount(dataMap()); + } + + @Override + boolean hasNodes() { + return nodeMap() != 0; + } + + @Override + int nodeArity() { + return java.lang.Integer.bitCount(nodeMap()); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + (nodeMap()); + result = prime * result + (dataMap()); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedMapNode that = (BitmapIndexedMapNode) other; + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + if (!ArrayUtils.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + if (this.nodeArity() == 0) { + switch (this.payloadArity()) { + case 0: + return SIZE_EMPTY; + case 1: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } else { + return SIZE_MORE_THAN_ONE; + } + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos) + 1; + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = val; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(bitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = val; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + return nodeOf(mutator, nodeMap(), dataMap() | bitpos, dst); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + return nodeOf(mutator, nodeMap(), dataMap() ^ bitpos, dst); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2 + 1]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 2, dst, idxNew + 1, src.length - idxNew - 2); + + return nodeOf(mutator, nodeMap() | bitpos, dataMap() ^ bitpos, dst); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 2]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = node.getKey(0); + dst[idxNew + 1] = node.getValue(0); + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 2, src.length - idxOld - 1); + + return nodeOf(mutator, nodeMap() ^ bitpos, dataMap() | bitpos, dst); + } + + } + + private static final class HashCollisionMapNode extends CompactMapNode { + + private final K[] keys; + private final V[] vals; + private final int hash; + + HashCollisionMapNode(final int hash, final K[] keys, final V[] vals) { + this.keys = keys; + this.vals = vals; + this.hash = hash; + + assert payloadArity() >= 2; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (K k : keys) { + if (k.equals(key)) { + return true; + } + } + } + return false; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (K k : keys) { + if (cmp.compare(k, key) == 0) { + return true; + } + } + } + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (key.equals(_key)) { + final V val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (cmp.compare(key, _key) == 0) { + final V val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final V currentVal = vals[idx]; + + if (currentVal.equals(val)) { + return this; + } else { + // add new mapping + final V[] src = this.vals; + final V[] dst = (V[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode<>(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final V[] valsNew = (V[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode<>(keyHash, keysNew, valsNew); + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final V currentVal = vals[idx]; + + if (cmp.compare(currentVal, val) == 0) { + return this; + } else { + // add new mapping + final V[] src = this.vals; + final V[] dst = (V[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode<>(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final V[] valsNew = (V[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode<>(keyHash, keysNew, valsNew); + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final V currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final V theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details); + } else { + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final V[] valsNew = (V[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode<>(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final V currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final V theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details, cmp); + } else { + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final V[] valsNew = (V[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode<>(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return keys.length; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + int arity() { + return payloadArity(); + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + K getKey(final int index) { + return keys[index]; + } + + @Override + V getValue(final int index) { + return vals[index]; + } + + @Override + java.util.Map.Entry getKeyValueEntry(final int index) { + return entryOf(keys[index], vals[index]); + } + + @Override + public CompactMapNode getNode(int index) { + throw new IllegalStateException("Is leaf node."); + } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + hash; + result = prime * result + Arrays.hashCode(keys); + result = prime * result + Arrays.hashCode(vals); + return result; + } + + @Override + public boolean equals(Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + HashCollisionMapNode that = (HashCollisionMapNode) other; + + if (hash != that.hash) { + return false; + } + + if (arity() != that.arity()) { + return false; + } + + /* + * Linear scan for each key, because of arbitrary element order. + */ + outerLoop: + for (int i = 0; i < that.payloadArity(); i++) { + final Object otherKey = that.getKey(i); + final Object otherVal = that.getValue(i); + + for (int j = 0; j < keys.length; j++) { + final K key = keys[j]; + final V val = vals[j]; + + if (key.equals(otherKey) && val.equals(otherVal)) { + continue outerLoop; + } + } + return false; + } + + return true; + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + int nodeMap() { + throw new UnsupportedOperationException(); + } + + @Override + int dataMap() { + throw new UnsupportedOperationException(); + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractMapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractMapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractMapNode[] nodes = new AbstractMapNode[MAX_DEPTH]; + + AbstractMapIterator(AbstractMapNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractMapNode nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class MapSupplierIterator extends AbstractMapIterator + implements SupplierIterator { + + MapSupplierIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + @Override + public V get() { + return currentValueNode.getValue(currentValueCursor); + } + + } + + protected static class MapKeyIterator extends AbstractMapIterator + implements Iterator { + + MapKeyIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + protected static class MapValueIterator extends AbstractMapIterator + implements Iterator { + + MapValueIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public V next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getValue(currentValueCursor++); + } + } + + } + + protected static class MapEntryIterator extends AbstractMapIterator + implements Iterator> { + + MapEntryIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public java.util.Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKeyValueEntry(currentValueCursor++); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieMapNodeIterator implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieMapNodeIterator(AbstractMapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractMapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieMap implements Map.Transient { + + final private AtomicReference mutator; + private AbstractMapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieMap(TrieMap trieMap) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieMap.rootNode; + this.hashCode = trieMap.hashCode; + this.cachedSize = trieMap.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final java.util.Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean contains(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + @Override + public Optional apply(K key) { + return rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + } + + public V get(final Object o) { + try { + final K key = (K) o; + return apply(key).orElse(null); + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public V insert(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final V old = details.getReplacedValue(); + + final int valHashOld = old.hashCode(); + final int valHashNew = val.hashCode(); + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } else { + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + @Override + public boolean insertAll(final Map map) { + boolean modified = false; + + for (SupplierIterator it = map.iterator(); it.hasNext(); ) { + K key = it.next(); + V val = it.get(); + + final boolean isPresent = this.contains(key); + final V replaced = this.insert(key, val); + + if (!isPresent || replaced != null) { + modified = true; + } + + } + + return modified; + } + + @Override + public V remove(final K key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + @Override + public long size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public SupplierIterator iterator() { + return new TransientSupplierIterator<>(this); + } + + public Iterator keyIterator() { + return new TransientMapKeyIterator<>(this); + } + + public Iterator valueIterator() { + return new TransientMapValueIterator<>(this); + } + + @Override + public Iterator> entryIterator() { + return new TransientMapEntryIterator<>(this); + } + + public static class TransientSupplierIterator extends MapSupplierIterator { + + final TransientTrieMap collection; + K lastKey; + + public TransientSupplierIterator(final TransientTrieMap collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.remove(lastKey); + } + } + + public static class TransientMapKeyIterator extends MapKeyIterator { + + final TransientTrieMap collection; + K lastKey; + + public TransientMapKeyIterator(final TransientTrieMap collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.remove(lastKey); + } + } + + public static class TransientMapValueIterator extends MapValueIterator { + + final TransientTrieMap collection; + + public TransientMapValueIterator(final TransientTrieMap collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public V next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientMapEntryIterator extends MapEntryIterator { + + final TransientTrieMap collection; + + public TransientMapEntryIterator(final TransientTrieMap collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public java.util.Map.Entry next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + // @Override + // public Set keySet() { + // Set keySet = null; + // + // if (keySet == null) { + // keySet = new AbstractSet() { + // @Override + // public Iterator iterator() { + // return TransientTrieMap.this.keyIterator(); + // } + // + // @Override + // public int size() { + // return TransientTrieMap.this.size(); + // } + // + // @Override + // public boolean isEmpty() { + // return TransientTrieMap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // TransientTrieMap.this.clear(); + // } + // + // @Override + // public boolean contains(Object k) { + // return TransientTrieMap.this.contains(k); + // } + // }; + // } + // + // return keySet; + // } + // + // @Override + // public Collection values() { + // Collection values = null; + // + // if (values == null) { + // values = new AbstractCollection() { + // @Override + // public Iterator iterator() { + // return TransientTrieMap.this.valueIterator(); + // } + // + // @Override + // public int size() { + // return TransientTrieMap.this.size(); + // } + // + // @Override + // public boolean isEmpty() { + // return TransientTrieMap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // TransientTrieMap.this.clear(); + // } + // + // @Override + // public boolean contains(Object v) { + // return TransientTrieMap.this.containsValue(v); + // } + // }; + // } + // + // return values; + // } + // + // @Override + // public Set> entrySet() { + // Set> entrySet = null; + // + // if (entrySet == null) { + // entrySet = new AbstractSet>() { + // @Override + // public Iterator> iterator() { + // return new Iterator>() { + // private final Iterator> i = entryIterator(); + // + // @Override + // public boolean hasNext() { + // return i.hasNext(); + // } + // + // @Override + // public java.util.Map.Entry next() { + // return i.next(); + // } + // + // @Override + // public void remove() { + // i.remove(); + // } + // }; + // } + // + // @Override + // public int size() { + // return TransientTrieMap.this.size(); + // } + // + // @Override + // public boolean isEmpty() { + // return TransientTrieMap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // TransientTrieMap.this.clear(); + // } + // + // @Override + // public boolean contains(Object k) { + // return TransientTrieMap.this.contains(k); + // } + // }; + // } + // + // return entrySet; + // } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieMap) { + TransientTrieMap that = (TransientTrieMap) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) { + return false; + } + + for (SupplierIterator it = that.iterator(); it.hasNext(); ) { + try { + final K key = it.next(); + final Optional result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + final V val = it.get(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public Map.Immutable asImmutable() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieMap(rootNode, hashCode, cachedSize); + } + } + + private static class TrieMapAsImmutableJdkCollection extends java.util.AbstractMap { + + private final AbstractMapNode rootNode; + private final int cachedSize; + + private TrieMapAsImmutableJdkCollection(TrieMap original) { + this.rootNode = original.rootNode; + this.cachedSize = original.cachedSize; + } + + private TrieMapAsImmutableJdkCollection(TransientTrieMap original) { + this.rootNode = original.rootNode; + this.cachedSize = original.cachedSize; + } + + @Override + public java.util.Set> entrySet() { + java.util.Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new MapEntryIterator<>(rootNode); + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + }; + } + + return entrySet; + } + + @Override + public int size() { + return cachedSize; + } + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/core/experimental/TrieSet.java b/capsule-experimental/src/main/java/io/usethesource/capsule/core/experimental/TrieSet.java new file mode 100644 index 0000000..533ed2e --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/core/experimental/TrieSet.java @@ -0,0 +1,2002 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.core.experimental; + +import java.text.DecimalFormat; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Optional; +import java.util.concurrent.atomic.AtomicReference; + +import io.usethesource.capsule.api.experimental.Set; +import io.usethesource.capsule.util.ArrayUtils; + +public class TrieSet implements Set.Immutable { + + private static final TrieSet EMPTY_SET = new TrieSet(CompactSetNode.EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractSetNode rootNode; + private final int cachedHashCode; + private final int cachedSize; + + TrieSet(AbstractSetNode rootNode, int hashCode, int cachedSize) { + this.rootNode = rootNode; + this.cachedHashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final Set.Immutable of() { + return TrieSet.EMPTY_SET; + } + + public static final Set.Immutable of(K key0) { + final int keyHash0 = key0.hashCode(); + + final int nodeMap = 0; + final int dataMap = CompactSetNode.bitpos(CompactSetNode.mask(keyHash0, 0)); + + CompactSetNode newRootNode = CompactSetNode.nodeOf(null, nodeMap, dataMap, key0); + + return new TrieSet(newRootNode, keyHash0, 1); + } + + public static final Set.Immutable of(K key0, K key1) { + assert !Objects.equals(key0, key1); + + final int keyHash0 = key0.hashCode(); + final int keyHash1 = key1.hashCode(); + + CompactSetNode newRootNode = + CompactSetNode.mergeTwoKeyValPairs(key0, keyHash0, key1, keyHash1, 0); + + return new TrieSet(newRootNode, keyHash0 + keyHash1, 2); + } + + public static final Set.Immutable of(K... keys) { + Set.Immutable result = TrieSet.EMPTY_SET; + + for (final K key : keys) { + result = result.insert(key); + } + + return result; + } + + public static final Set.Transient transientOf() { + return TrieSet.EMPTY_SET.asTransient(); + } + + public static final Set.Transient transientOf(K... keys) { + final Set.Transient result = TrieSet.EMPTY_SET.asTransient(); + + for (final K key : keys) { + result.insert(key); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator it = keyIterator(); it.hasNext(); ) { + final K key = it.next(); + + hash += key.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + private static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean contains(final Object o) { + try { + final K key = (K) o; + return rootNode.contains(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public Optional apply(K key) { + return rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + } + + public K get(final Object o) { + try { + final K key = (K) o; + return apply(key).orElse(null); + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public Set.Immutable insert(final K key) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + return new TrieSet(newRootNode, cachedHashCode ^ keyHash, cachedSize + 1); + } + + return this; + } + + @Override + public Set.Immutable remove(final K key) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + return new TrieSet(newRootNode, cachedHashCode ^ keyHash, cachedSize - 1); + } + + return this; + } + + @Override + public Set.Immutable insertAll(final Set set) { + final Set.Transient tmpTransient = this.asTransient(); + tmpTransient.insertAll(set); + return tmpTransient.asImmutable(); + } + + @Override + public Set.Immutable removeAll(final Set set) { + final Set.Transient tmpTransient = this.asTransient(); + tmpTransient.removeAll(set); + return tmpTransient.asImmutable(); + } + + @Override + public Set.Immutable retainAll(final Set set) { + final Set.Transient tmpTransient = this.asTransient(); + tmpTransient.retainAll(set); + return tmpTransient.asImmutable(); + } + + @Override + public long size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator iterator() { + return keyIterator(); + } + + private Iterator keyIterator() { + return new SetKeyIterator<>(rootNode); + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieSet) { + TrieSet that = (TrieSet) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.cachedHashCode != that.cachedHashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Set) { + Set that = (Set) other; + + if (this.size() != that.size()) { + return false; + } + + return containsAll(that); + } + + return false; + } + + @Override + public int hashCode() { + return cachedHashCode; + } + + @Override + public java.util.Set asJdkCollection() { + return new TrieSetAsImmutableJdkCollection<>(this); + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public Set.Transient asTransient() { + return new TransientTrieSet(this); + } + + @Override + public Set.Immutable asImmutable() { + return this; + } + + /* + * For analysis purposes only. + */ + protected AbstractSetNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new SetNodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. Payload X Node + */ + protected int[][] arityCombinationsHistogram() { + final Iterator> it = nodeIterator(); + final int[][] sumArityCombinations = new int[33][33]; + + while (it.hasNext()) { + final AbstractSetNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[33]; + + final int maxArity = 32; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[33]; + for (int cumsum = 0, i = 0; i < 33; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 33; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + static final class SetResult { + + private K replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(K replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static SetResult unchanged() { + return new SetResult<>(); + } + + private SetResult() { + } + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public K getReplacedValue() { + return replacedValue; + } + } + + protected static interface INode { + + } + + protected static abstract class AbstractSetNode implements INode { + + static final int TUPLE_LENGTH = 1; + + abstract boolean contains(final K key, final int keyHash, final int shift); + + abstract boolean contains(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final K key, final int keyHash, final int shift); + + abstract Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract CompactSetNode updated(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetResult details); + + abstract CompactSetNode updated(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetResult details, + final Comparator cmp); + + abstract CompactSetNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetResult details); + + abstract CompactSetNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetResult details, + final Comparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractSetNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractSetNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractSetNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractSetNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract K getKey(final int index); + + @Deprecated + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + int size() { + final Iterator it = new SetKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactSetNode extends AbstractSetNode { + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + abstract int nodeMap(); + + abstract int dataMap(); + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactSetNode getNode(final int index); + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactSetNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final K key); + + abstract CompactSetNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos); + + abstract CompactSetNode copyAndSetNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node); + + abstract CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node); + + abstract CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node); + + static final CompactSetNode mergeTwoKeyValPairs(final K key0, final int keyHash0, + final K key1, final int keyHash1, final int shift) { + assert !(key0.equals(key1)); + + if (shift >= HASH_CODE_LENGTH) { + return new HashCollisionSetNode<>(keyHash0, (K[]) new Object[]{key0, key1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int dataMap = bitpos(mask0) | bitpos(mask1); + + if (mask0 < mask1) { + return nodeOf(null, (0), dataMap, new Object[]{key0, key1}); + } else { + return nodeOf(null, (0), dataMap, new Object[]{key1, key0}); + } + } else { + final CompactSetNode node = + mergeTwoKeyValPairs(key0, keyHash0, key1, keyHash1, shift + BIT_PARTITION_SIZE); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf(null, nodeMap, (0), new Object[]{node}); + } + } + + static final CompactSetNode EMPTY_NODE; + + static { + + EMPTY_NODE = new BitmapIndexedSetNode<>(null, (0), (0), new Object[]{}); + + } + + ; + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object[] nodes) { + return new BitmapIndexedSetNode<>(mutator, nodeMap, dataMap, nodes); + } + + static final CompactSetNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactSetNode nodeOf(AtomicReference mutator, final int nodeMap, + final int dataMap, final K key) { + assert nodeMap == 0; + return nodeOf(mutator, (0), dataMap, new Object[]{key}); + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + CompactSetNode nodeAt(final int bitpos) { + return getNode(nodeIndex(bitpos)); + } + + @Override + boolean contains(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index).equals(key); + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).contains(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return false; + } + + @Override + boolean contains(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return cmp.compare(getKey(index), key) == 0; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).contains(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index).equals(key)) { + return Optional.of(getKey(index)); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractSetNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (cmp.compare(getKey(index), key) == 0) { + return Optional.of(getKey(index)); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractSetNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return Optional.empty(); + } + + @Override + CompactSetNode updated(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (currentKey.equals(key)) { + return this; + } else { + final CompactSetNode subNodeNew = mergeTwoKeyValPairs(currentKey, + transformHashCode(currentKey.hashCode()), key, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.updated(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key); + } + } + + @Override + CompactSetNode updated(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (cmp.compare(currentKey, key) == 0) { + return this; + } else { + final CompactSetNode subNodeNew = mergeTwoKeyValPairs(currentKey, + transformHashCode(currentKey.hashCode()), key, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.updated(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key); + } + } + + @Override + CompactSetNode removed(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex).equals(key)) { + details.modified(); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactSetNode.nodeOf(mutator, 0, newDataMap, getKey(1)); + } else { + return CompactSetNode.nodeOf(mutator, 0, newDataMap, getKey(0)); + } + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (this.payloadArity() == 0 && this.nodeArity() == 1) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + @Override + CompactSetNode removed(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (cmp.compare(getKey(dataIndex), key) == 0) { + details.modified(); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactSetNode.nodeOf(mutator, 0, newDataMap, getKey(1)); + } else { + return CompactSetNode.nodeOf(mutator, 0, newDataMap, getKey(0)); + } + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (this.payloadArity() == 0 && this.nodeArity() == 1) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d<#%d>", pos, Objects.hashCode(getKey(i)))); + + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedSetNode extends CompactSetNode { + + private final int nodeMap; + private final int dataMap; + + CompactMixedSetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + private static final class BitmapIndexedSetNode extends CompactMixedSetNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedSetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + super(mutator, nodeMap, dataMap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + + assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < TUPLE_LENGTH * payloadArity(); i++) { + assert ((nodes[i] instanceof CompactSetNode) == false); + } + for (int i = TUPLE_LENGTH * payloadArity(); i < nodes.length; i++) { + assert ((nodes[i] instanceof CompactSetNode) == true); + } + } + + assert nodeInvariant(); + } + + @Override + K getKey(final int index) { + return (K) nodes[TUPLE_LENGTH * index]; + } + + @Override + CompactSetNode getNode(final int index) { + return (CompactSetNode) nodes[nodes.length - 1 - index]; + } + + @Override + boolean hasPayload() { + return dataMap() != 0; + } + + @Override + int payloadArity() { + return java.lang.Integer.bitCount(dataMap()); + } + + @Override + boolean hasNodes() { + return nodeMap() != 0; + } + + @Override + int nodeArity() { + return java.lang.Integer.bitCount(nodeMap()); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + (nodeMap()); + result = prime * result + (dataMap()); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedSetNode that = (BitmapIndexedSetNode) other; + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + if (!ArrayUtils.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + if (this.nodeArity() == 0) { + switch (this.payloadArity()) { + case 0: + return SIZE_EMPTY; + case 1: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } else { + return SIZE_MORE_THAN_ONE; + } + } + + @Override + CompactSetNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactSetNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(bitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactSetNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length + 1]; + + // copy 'src' and insert 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + System.arraycopy(src, idx, dst, idx + 1, src.length - idx); + + return nodeOf(mutator, nodeMap(), dataMap() | bitpos, dst); + } + + @Override + CompactSetNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1]; + + // copy 'src' and remove 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 1, dst, idx, src.length - idx - 1); + + return nodeOf(mutator, nodeMap(), dataMap() ^ bitpos, dst); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 1]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 1, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 1, dst, idxNew + 1, src.length - idxNew - 1); + + return nodeOf(mutator, nodeMap() | bitpos, dataMap() ^ bitpos, dst); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 1]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = node.getKey(0); + System.arraycopy(src, idxNew, dst, idxNew + 1, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 1, src.length - idxOld - 1); + + return nodeOf(mutator, nodeMap() ^ bitpos, dataMap() | bitpos, dst); + } + + } + + private static final class HashCollisionSetNode extends CompactSetNode { + + private final K[] keys; + + private final int hash; + + HashCollisionSetNode(final int hash, final K[] keys) { + this.keys = keys; + + this.hash = hash; + + assert payloadArity() >= 2; + } + + @Override + boolean contains(final K key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (K k : keys) { + if (k.equals(key)) { + return true; + } + } + } + return false; + } + + @Override + boolean contains(final K key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (K k : keys) { + if (cmp.compare(k, key) == 0) { + return true; + } + } + } + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (key.equals(_key)) { + return Optional.of(_key); + } + } + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (cmp.compare(key, _key) == 0) { + return Optional.of(_key); + } + } + return Optional.empty(); + } + + @Override + CompactSetNode updated(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + return this; + } + } + + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + details.modified(); + return new HashCollisionSetNode<>(keyHash, keysNew); + } + + @Override + CompactSetNode updated(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + return this; + } + } + + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + details.modified(); + return new HashCollisionSetNode<>(keyHash, keysNew); + } + + @Override + CompactSetNode removed(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + details.modified(); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + + return CompactSetNode.nodeOf(mutator).updated(mutator, theOtherKey, keyHash, 0, + details); + } else { + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + return new HashCollisionSetNode<>(keyHash, keysNew); + } + } + } + return this; + } + + @Override + CompactSetNode removed(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + details.modified(); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + + return CompactSetNode.nodeOf(mutator).updated(mutator, theOtherKey, keyHash, 0, + details, cmp); + } else { + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + return new HashCollisionSetNode<>(keyHash, keysNew); + } + } + } + return this; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return keys.length; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + int arity() { + return payloadArity(); + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + K getKey(final int index) { + return keys[index]; + } + + @Override + public CompactSetNode getNode(int index) { + throw new IllegalStateException("Is leaf node."); + } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + hash; + result = prime * result + Arrays.hashCode(keys); + return result; + } + + @Override + public boolean equals(Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + HashCollisionSetNode that = (HashCollisionSetNode) other; + + if (hash != that.hash) { + return false; + } + + if (arity() != that.arity()) { + return false; + } + + /* + * Linear scan for each key, because of arbitrary element order. + */ + outerLoop: + for (int i = 0; i < that.payloadArity(); i++) { + final Object otherKey = that.getKey(i); + + for (int j = 0; j < keys.length; j++) { + final K key = keys[j]; + + if (key.equals(otherKey)) { + continue outerLoop; + } + } + return false; + + } + + return true; + } + + @Override + CompactSetNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactSetNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new UnsupportedOperationException(); + } + + @Override + int nodeMap() { + throw new UnsupportedOperationException(); + } + + @Override + int dataMap() { + throw new UnsupportedOperationException(); + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractSetNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractSetNode[] nodes = new AbstractSetNode[MAX_DEPTH]; + + AbstractSetIterator(AbstractSetNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractSetNode nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetKeyIterator extends AbstractSetIterator implements Iterator { + + SetKeyIterator(AbstractSetNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class SetNodeIterator implements Iterator> { + + final Deque>> nodeIteratorStack; + + SetNodeIterator(AbstractSetNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractSetNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractSetNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieSet implements Set.Transient { + + final private AtomicReference mutator; + private AbstractSetNode rootNode; + private int cachedHashCode; + private int cachedSize; + + TransientTrieSet(TrieSet trieSet) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieSet.rootNode; + this.cachedHashCode = trieSet.cachedHashCode; + this.cachedSize = trieSet.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(cachedHashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator it = keyIterator(); it.hasNext(); ) { + final K key = it.next(); + + hash += key.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean contains(final Object o) { + try { + final K key = (K) o; + return rootNode.contains(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public Optional apply(K key) { + return rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + } + + public K get(final Object o) { + try { + final K key = (K) o; + return apply(key).orElse(null); + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public boolean insert(final K key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + + rootNode = newRootNode; + cachedHashCode ^= keyHash; + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(cachedHashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(cachedHashCode, cachedSize); + } + return false; + } + + @Override + public boolean remove(final K key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + rootNode = newRootNode; + cachedHashCode = cachedHashCode ^ keyHash; + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(cachedHashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(cachedHashCode, cachedSize); + } + + return false; + } + + @Override + public boolean insertAll(final Set set) { + boolean modified = false; + + for (final K key : set) { + modified |= this.insert(key); + } + + return modified; + } + + @Override + public boolean removeAll(final Set set) { + boolean modified = false; + + for (final K key : set) { + modified |= this.remove(key); + } + + return modified; + } + + @Override + public boolean retainAll(final Set set) { + boolean modified = false; + + Iterator thisIterator = iterator(); + while (thisIterator.hasNext()) { + if (!set.contains(thisIterator.next())) { + thisIterator.remove(); + modified = true; + } + } + + return modified; + } + + @Override + public long size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator iterator() { + return keyIterator(); + } + + private Iterator keyIterator() { + return new TransientSetKeyIterator<>(this); + } + + public static class TransientSetKeyIterator extends SetKeyIterator { + + final TransientTrieSet collection; + K lastKey; + + public TransientSetKeyIterator(final TransientTrieSet collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.remove(lastKey); + } + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieSet) { + TransientTrieSet that = (TransientTrieSet) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.cachedHashCode != that.cachedHashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Set) { + Set that = (Set) other; + + if (this.size() != that.size()) { + return false; + } + + return contains(that); + } + + return false; + } + + @Override + public int hashCode() { + return cachedHashCode; + } + + // @Override + // public java.util.Set asJdkCollection() { + // throw new UnsupportedOperationException("Not yet implemented."); + // } + + @Override + public Set.Immutable asImmutable() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieSet(rootNode, cachedHashCode, cachedSize); + } + } + + private static class TrieSetAsImmutableJdkCollection extends java.util.AbstractSet { + + private final AbstractSetNode rootNode; + private final int cachedSize; + + private TrieSetAsImmutableJdkCollection(TrieSet original) { + this.rootNode = original.rootNode; + this.cachedSize = original.cachedSize; + } + + private TrieSetAsImmutableJdkCollection(TransientTrieSet original) { + this.rootNode = original.rootNode; + this.cachedSize = original.cachedSize; + } + + @Override + public boolean contains(final Object o) { + try { + final K key = (K) o; + return rootNode.contains(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public Iterator iterator() { + return new SetKeyIterator<>(rootNode); + } + + @Override + public int size() { + return cachedSize; + } + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/heterogeneous/TrieMap_5Bits_Heterogeneous_BleedingEdge.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/heterogeneous/TrieMap_5Bits_Heterogeneous_BleedingEdge.java new file mode 100644 index 0000000..470e7b2 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/heterogeneous/TrieMap_5Bits_Heterogeneous_BleedingEdge.java @@ -0,0 +1,4815 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.heterogeneous; + +import java.lang.reflect.Field; +import java.text.DecimalFormat; +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.atomic.AtomicReference; +import java.util.stream.Stream; + +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_5Bits_Heterogeneous_BleedingEdge_IntIntSpecializations.Map0To0Node_5Bits_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_5Bits_Heterogeneous_BleedingEdge_IntIntSpecializations.Map0To1Node_5Bits_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_5Bits_Heterogeneous_BleedingEdge_IntIntSpecializations.Map0To2Node_5Bits_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_5Bits_Heterogeneous_BleedingEdge_IntIntSpecializations.Map0To4Node_5Bits_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_5Bits_Heterogeneous_BleedingEdge_IntIntSpecializations.Map1To0Node_5Bits_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_5Bits_Heterogeneous_BleedingEdge_IntIntSpecializations.Map1To2Node_5Bits_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_5Bits_Heterogeneous_BleedingEdge_IntIntSpecializations.Map2To0Node_5Bits_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.util.RangecopyUtils.AbstractArrayView; +import io.usethesource.capsule.util.RangecopyUtils.Companion; +import io.usethesource.capsule.util.RangecopyUtils.EitherIntOrObject; +import io.usethesource.capsule.util.RangecopyUtils.IntArrayView; +import io.usethesource.capsule.util.RangecopyUtils.ObjectArrayView; + +import static io.usethesource.capsule.util.BitmapUtils.isBitInBitmap; +import static io.usethesource.capsule.util.RangecopyUtils.getFromObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.rangecopyIntRegion; +import static io.usethesource.capsule.util.RangecopyUtils.rangecopyObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.setInIntRegion; +import static io.usethesource.capsule.util.RangecopyUtils.setInIntRegionVarArgs; +import static io.usethesource.capsule.util.RangecopyUtils.setInObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.setInObjectRegionVarArgs; +import static io.usethesource.capsule.util.RangecopyUtils.sizeOfObject; +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +public class TrieMap_5Bits_Heterogeneous_BleedingEdge implements + io.usethesource.capsule.Map.Immutable { + + protected static final AbstractMapNode EMPTY_NODE = + new Map0To0Node_5Bits_Heterogeneous_BleedingEdge(null, (int) 0, (int) 0); + + private static final TrieMap_5Bits_Heterogeneous_BleedingEdge EMPTY_MAP = + new TrieMap_5Bits_Heterogeneous_BleedingEdge(EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractMapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieMap_5Bits_Heterogeneous_BleedingEdge(AbstractMapNode rootNode, int hashCode, int cachedSize) { + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final io.usethesource.capsule.Map.Immutable of() { + return TrieMap_5Bits_Heterogeneous_BleedingEdge.EMPTY_MAP; + } + + public static final io.usethesource.capsule.Map.Immutable of( + Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + io.usethesource.capsule.Map.Immutable result = TrieMap_5Bits_Heterogeneous_BleedingEdge.EMPTY_MAP; + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final int key = (int) keyValuePairs[i]; + final int val = (int) keyValuePairs[i + 1]; + + result = result.__put(key, val); + } + + return result; + } + + public static final io.usethesource.capsule.Map.Transient transientOf() { + return TrieMap_5Bits_Heterogeneous_BleedingEdge.EMPTY_MAP.asTransient(); + } + + public static final io.usethesource.capsule.Map.Transient transientOf( + Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + final io.usethesource.capsule.Map.Transient result = + TrieMap_5Bits_Heterogeneous_BleedingEdge.EMPTY_MAP.asTransient(); + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final int key = (int) keyValuePairs[i]; + final int val = (int) keyValuePairs[i + 1]; + + result.__put(key, val); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final Object key = entry.getKey(); + final Object val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + public boolean containsKey(final int key) { + return rootNode.containsKey(key, transformHashCode(key), 0); + } + + public boolean containsKeyEquivalent(final int key, final Comparator cmp) { + return rootNode.containsKeyEquivalent(key, transformHashCode(key), 0, cmp); + } + + @Override + public boolean containsKey(final Object o) { + try { + final Object key = (Object) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + final Object key = (Object) o; + return rootNode.containsKeyEquivalent(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + @Override + public Object get(final Object o) { + try { + final int key = (int) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public Object getEquivalent(final Object o, final Comparator cmp) { + try { + final int key = (int) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public io.usethesource.capsule.Map.Immutable __put(final int key, + final int val) { + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().getInt(); + + final int valHashNew = val; + + return new TrieMap_5Bits_Heterogeneous_BleedingEdge(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val; + + return new TrieMap_5Bits_Heterogeneous_BleedingEdge(newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + public io.usethesource.capsule.Map.Immutable __putEquivalent(final int key, + final int val, + final Comparator cmp) { + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().getInt(); + final int valHashNew = val; + + return new TrieMap_5Bits_Heterogeneous_BleedingEdge(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val; + + return new TrieMap_5Bits_Heterogeneous_BleedingEdge(newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __put(final Object key, + final Object val) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().getObject().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieMap_5Bits_Heterogeneous_BleedingEdge(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val.hashCode(); + + return new TrieMap_5Bits_Heterogeneous_BleedingEdge(newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __putEquivalent(final Object key, + final Object val, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().getObject().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieMap_5Bits_Heterogeneous_BleedingEdge(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val.hashCode(); + + return new TrieMap_5Bits_Heterogeneous_BleedingEdge(newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __putAll( + final Map map) { + final io.usethesource.capsule.Map.Transient tmpTransient = this + .asTransient(); + tmpTransient.__putAll(map); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Map.Immutable __putAllEquivalent( + final Map map, final Comparator cmp) { + final io.usethesource.capsule.Map.Transient tmpTransient = this + .asTransient(); + tmpTransient.__putAllEquivalent(map, cmp); + return tmpTransient.freeze(); + } + + public io.usethesource.capsule.Map.Immutable __remove(final int key) { + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getInt(); + return new TrieMap_5Bits_Heterogeneous_BleedingEdge(newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + public io.usethesource.capsule.Map.Immutable __removeEquivalent(final int key, + final Comparator cmp) { + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getInt(); + return new TrieMap_5Bits_Heterogeneous_BleedingEdge(newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __remove(final Object key) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getObject().hashCode(); + return new TrieMap_5Bits_Heterogeneous_BleedingEdge(newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __removeEquivalent( + final Object key, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getObject().hashCode(); + return new TrieMap_5Bits_Heterogeneous_BleedingEdge(newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + @Override + public Object put(final Object key, final Object val) { + throw new UnsupportedOperationException(); + } + + @Override + public void putAll(final Map m) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public Object remove(final Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new MapKeyIterator(rootNode); + } + + @Override + public Iterator valueIterator() { + return new MapValueIterator(rootNode); + } + + @Override + public Iterator> entryIterator() { + return new MapEntryIterator(rootNode); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_Heterogeneous_BleedingEdge.this.keyIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_Heterogeneous_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Heterogeneous_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Heterogeneous_BleedingEdge.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_Heterogeneous_BleedingEdge.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_Heterogeneous_BleedingEdge.this.valueIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_Heterogeneous_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Heterogeneous_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Heterogeneous_BleedingEdge.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TrieMap_5Bits_Heterogeneous_BleedingEdge.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieMap_5Bits_Heterogeneous_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Heterogeneous_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Heterogeneous_BleedingEdge.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_Heterogeneous_BleedingEdge.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieMap_5Bits_Heterogeneous_BleedingEdge) { + TrieMap_5Bits_Heterogeneous_BleedingEdge that = + (TrieMap_5Bits_Heterogeneous_BleedingEdge) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final Object key = (Object) entry.getKey(); + final Optional result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + final Object val = (Object) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public io.usethesource.capsule.Map.Transient asTransient() { + return new TransientTrieMap_5Bits_Heterogeneous_BleedingEdge(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractMapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator nodeIterator() { + return new TrieMap_5Bits_Heterogeneous_BleedingEdgeNodeIterator(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. + */ + protected int[][] arityCombinationsHistogram() { + final Iterator it = nodeIterator(); + final int[][] sumArityCombinations = new int[33][33]; + + while (it.hasNext()) { + final AbstractMapNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[33]; + + final int maxArity = 32; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[33]; + for (int cumsum = 0, i = 0; i < 33; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 33; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + abstract static class Optional { + + private static final Optional EMPTY = new Optional() { + @Override + boolean isPresent() { + return false; + } + + @Override + Object get() { + return null; + } + }; + + static Optional empty() { + return EMPTY; + } + + static Optional of(T value) { + return new Value(value); + } + + abstract boolean isPresent(); + + abstract T get(); + + private static final class Value extends Optional { + + private final T value; + + private Value(T value) { + this.value = value; + } + + @Override + boolean isPresent() { + return true; + } + + @Override + T get() { + return value; + } + } + } + + static final class MapResult { + + private EitherIntOrObject replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(EitherIntOrObject replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static MapResult unchanged() { + return new MapResult(); + } + + private MapResult() { + } + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public EitherIntOrObject getReplacedValue() { + return replacedValue; + } + } + + protected static interface INode { + + } + + protected abstract static class AbstractMapNode { + + protected static final sun.misc.Unsafe initializeUnsafe() { + try { + Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe"); + field.setAccessible(true); + return (sun.misc.Unsafe) field.get(null); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + protected static final sun.misc.Unsafe unsafe = initializeUnsafe(); + + protected static final int TUPLE_LENGTH = 2; + + protected static final boolean isAllowedToEdit(final AtomicReference x, + final AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean containsKey(final int key, final int keyHash, final int shift); + + abstract boolean containsKeyEquivalent(final int key, final int keyHash, final int shift, + final Comparator cmp); + + abstract boolean containsKey(final Object key, final int keyHash, final int shift); + + abstract boolean containsKeyEquivalent(final Object key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final int key, final int keyHash, final int shift); + + abstract Optional findByKey(final int key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final Object key, final int keyHash, final int shift); + + abstract Optional findByKey(final Object key, final int keyHash, final int shift, + final Comparator cmp); + + abstract AbstractMapNode updated(final AtomicReference mutator, final int key, + final int val, final int keyHash, final int shift, final MapResult details); + + abstract AbstractMapNode updated(final AtomicReference mutator, final int key, + final int val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + abstract AbstractMapNode updated(final AtomicReference mutator, final Object key, + final Object val, final int keyHash, final int shift, final MapResult details); + + abstract AbstractMapNode updated(final AtomicReference mutator, final Object key, + final Object val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + abstract public AbstractMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details); + + abstract public AbstractMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp); + + abstract public AbstractMapNode removed(final AtomicReference mutator, final Object key, + final int keyHash, final int shift, final MapResult details); + + abstract public AbstractMapNode removed(final AtomicReference mutator, final Object key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp); + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractMapNode getNode(final int index); + + Iterator nodeIterator() { + return new Iterator() { + int nextIndex = 0; + final int nodeArity = AbstractMapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractMapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract int rarePayloadArity(); + + abstract int getKey(final int index); + + abstract int getVal(final int index); + + abstract Map.Entry getKeyValueEntry(final int index); + + abstract Object getRareKey(final int index); + + abstract Object getRareVal(final int index); + + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + abstract int untypedSlotArity(); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + int size() { + final Iterator it = new MapKeyIterator(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + ; + return size; + } + + static final byte sizeEmpty() { + return 0b0; + } + + static final byte sizeOne() { + return 0b1; + } + + static final byte sizeMoreThanOne() { + return 0b10; + } + + byte sizePredicate() { + if (this.nodeArity() == 0) { + switch (this.payloadArity() + this.rarePayloadArity()) { + case 0: + return sizeEmpty(); + case 1: + return sizeOne(); + default: + return sizeMoreThanOne(); + } + } else { + return sizeMoreThanOne(); + } + } + + abstract public boolean equals(final Object other); + + abstract public String toString(); + } + + protected abstract static class CompactMapNode extends AbstractMapNode { + + protected CompactMapNode(final AtomicReference mutator, final int rawMap1, + final int rawMap2) { + this.rawMap1 = rawMap1; + this.rawMap2 = rawMap2; + } + + static final long initializeArrayBase() { + try { + // assuems that both are of type Object and next to each other in memory + return DataLayoutHelper.arrayOffsets[0]; + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + static final long arrayBase = initializeArrayBase(); + + static final long initializeAddressSize() { + try { + // assuems that both are of type Object and next to each other in memory + return DataLayoutHelper.arrayOffsets[1] - DataLayoutHelper.arrayOffsets[0]; + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + static final long addressSize = initializeAddressSize(); + + static final Class[][] initializeSpecializationsByContentAndNodes() { + Class[][] next = new Class[33][65]; + + try { + for (int m = 0; m <= 32; m++) { + for (int n = 0; n <= 64; n++) { + int mNext = m; + int nNext = n; + + // TODO: last expression is not properly generated yet and maybe incorrect + if (mNext < 0 || mNext > 32 || nNext < 0 || nNext > 64 + || Math.ceil(nNext / 2.0) + mNext > 32) { + next[m][n] = null; + } else { + next[m][n] = Class.forName(String.format( + "io.usethesource.capsule.experimental.heterogeneous.TrieMap_5Bits_Heterogeneous_BleedingEdge_IntIntSpecializations$Map%dTo%dNode_5Bits_Heterogeneous_BleedingEdge", + mNext, nNext)); + } + } + } + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } + + return next; + } + + static final Class[][] specializationsByContentAndNodes = + initializeSpecializationsByContentAndNodes(); + + static long globalRawMap1Offset = + fieldOffset(Map0To2Node_5Bits_Heterogeneous_BleedingEdge.class, "rawMap1"); + + static long globalRawMap2Offset = + fieldOffset(Map0To2Node_5Bits_Heterogeneous_BleedingEdge.class, "rawMap2"); + + static long globalArrayOffsetsOffset = + fieldOffset(Map0To2Node_5Bits_Heterogeneous_BleedingEdge.class, "arrayOffsets"); + + static long globalNodeArityOffset = + fieldOffset(Map0To2Node_5Bits_Heterogeneous_BleedingEdge.class, "nodeArity"); + + static long globalPayloadArityOffset = + fieldOffset(Map0To2Node_5Bits_Heterogeneous_BleedingEdge.class, "payloadArity"); + + static long globalSlotArityOffset = + fieldOffset(Map0To2Node_5Bits_Heterogeneous_BleedingEdge.class, "slotArity"); + + static long globalUntypedSlotArityOffset = + fieldOffset(Map0To2Node_5Bits_Heterogeneous_BleedingEdge.class, "untypedSlotArity"); + + static long globalRareBaseOffset = + fieldOffset(Map0To2Node_5Bits_Heterogeneous_BleedingEdge.class, "rareBase"); + + static long globalArrayOffsetLastOffset = + fieldOffset(Map0To2Node_5Bits_Heterogeneous_BleedingEdge.class, "arrayOffsetLast"); + + static long globalNodeBaseOffset = + fieldOffset(Map0To2Node_5Bits_Heterogeneous_BleedingEdge.class, "nodeBase"); + + Companion getCompanion() { + + Class clazz = this.getClass(); + + int nodeArity = unsafe.getInt(clazz, globalNodeArityOffset); + int payloadArity = unsafe.getInt(clazz, globalPayloadArityOffset); + int slotArity = unsafe.getInt(clazz, globalSlotArityOffset); + int untypedSlotArity = unsafe.getInt(clazz, globalUntypedSlotArityOffset); + long rareBase = unsafe.getLong(clazz, globalRareBaseOffset); + long arrayOffsetLast = unsafe.getLong(clazz, globalArrayOffsetLastOffset); + long nodeBase = unsafe.getLong(clazz, globalNodeBaseOffset); + + return new Companion(nodeArity, payloadArity, slotArity, untypedSlotArity, rareBase, + arrayOffsetLast, nodeBase); + + } + + final AbstractArrayView getIntArrayView() { + final Class clazz = this.getClass(); + final int payloadArity = unsafe.getInt(clazz, globalPayloadArityOffset); + + return new IntArrayView(this, arrayBase, payloadArity * TUPLE_LENGTH); + } + + final ObjectArrayView getObjectArrayView() { + final Class clazz = this.getClass(); + final int untypedSlotArity = unsafe.getInt(clazz, globalUntypedSlotArityOffset); + final long rareBase = unsafe.getLong(clazz, globalRareBaseOffset); + + return new ObjectArrayView(this, rareBase, untypedSlotArity); + } + + static final int hashCodeLength() { + return 32; + } + + static final int bitPartitionSize() { + return 5; + } + + static final int bitPartitionMask() { + return 0b11111; + } + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & bitPartitionMask(); + } + + static final int bitpos(final int mask) { + return (int) (1 << mask); + } + + int nodeMap() { + return (int) (rawMap1() ^ rareMap()); + } + + int dataMap() { + return (int) (rawMap2() ^ rareMap()); + } + + int rareMap() { + return (int) (rawMap1() & rawMap2()); + } + + public int rawMap1() { + return rawMap1; + } + + private int rawMap1; + + public int rawMap2() { + return rawMap2; + } + + private int rawMap2; + + static final boolean isRare(final Object o) { + throw new UnsupportedOperationException(); // TODO: to implement + } + + static final boolean isRare(final Object o0, final Object o1) { + throw new UnsupportedOperationException(); // TODO: to implement + } + + static final boolean isRare(final int bitpos) { + throw new UnsupportedOperationException(); // TODO: to implement + } + + static final int getKey(final Class clazz, + final CompactMapNode instance, final int index) { + // TODO: generate global offset for begin of rare payload + // TODO: remove hard-coded sizeOf(int) + + long keyOffset = arrayBase + (TUPLE_LENGTH * index + 0) * 4; + return (int) unsafe.getInt(instance, keyOffset); + + } + + static final Object getRareKey(final Class clazz, + final CompactMapNode instance, final int index) { + // TODO: generate global offset for begin of rare payload + // TODO: remove hard-coded sizeOf(int) + + long rareBase = unsafe.getLong(clazz, globalRareBaseOffset); + long keyOffset = rareBase + (TUPLE_LENGTH * index + 0) * addressSize; + + return (Object) getFromObjectRegion(instance, rareBase, TUPLE_LENGTH * index + 0); + + } + + static final int getVal(final Class clazz, + final CompactMapNode instance, final int index) { + // TODO: generate global offset for begin of rare payload + // TODO: remove hard-coded sizeOf(int) + + long keyOffset = arrayBase + (TUPLE_LENGTH * index + 1) * 4; + return (int) unsafe.getInt(instance, keyOffset); + + } + + static final Object getRareVal(final Class clazz, + final CompactMapNode instance, final int index) { + // TODO: generate global offset for begin of rare payload + // TODO: remove hard-coded sizeOf(int) + + long rareBase = unsafe.getLong(clazz, globalRareBaseOffset); + long keyOffset = rareBase + (TUPLE_LENGTH * index + 1) * addressSize; + + return (Object) getFromObjectRegion(instance, rareBase, TUPLE_LENGTH * index + 1); + + } + + static final AbstractMapNode getNode(final Class clazz, + final CompactMapNode instance, final int index) { + final int untypedSlotArity = unsafe.getInt(clazz, globalUntypedSlotArityOffset); + final long rareBase = unsafe.getLong(clazz, globalRareBaseOffset); + + final int pIndex = untypedSlotArity - 1 - index; + + return (AbstractMapNode) getFromObjectRegion(instance, rareBase, pIndex); + } + + enum ContentType { + KEY, VAL, RARE_KEY, RARE_VAL, NODE, SLOT + } + + int logicalToPhysicalIndex(final ContentType type, final int index) { + final int physicalIndex; + + switch (type) { + case KEY: + physicalIndex = TUPLE_LENGTH * index; + break; + case VAL: + physicalIndex = TUPLE_LENGTH * index + 1; + break; + case RARE_KEY: + physicalIndex = + TUPLE_LENGTH * index + TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap()); + break; + case RARE_VAL: + physicalIndex = + TUPLE_LENGTH * index + TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap()) + 1; + break; + case NODE: + physicalIndex = slotArity() - 1 - index; + break; + case SLOT: + physicalIndex = index; + break; + default: + throw new IllegalStateException("Cases not exhausted?"); + } + + return physicalIndex; + } + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == sizeEmpty() : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == sizeOne() : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == sizeMoreThanOne() : true; + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + static final long[] arrayOffsets(final Class clazz, final String[] fieldNames) { + try { + long[] arrayOffsets = new long[fieldNames.length]; + + for (int i = 0; i < fieldNames.length; i++) { + arrayOffsets[i] = unsafe.objectFieldOffset(clazz.getDeclaredField(fieldNames[i])); + } + + return arrayOffsets; + } catch (NoSuchFieldException | SecurityException e) { + throw new RuntimeException(e); + } + } + + static final long fieldOffset(final Class clazz, final String fieldName) { + try { + List bottomUpHierarchy = new LinkedList<>(); + + Class currentClass = clazz; + while (currentClass != null) { + bottomUpHierarchy.add(currentClass); + currentClass = currentClass.getSuperclass(); + } + + final java.util.Optional fieldNameField = bottomUpHierarchy.stream() + .flatMap(hierarchyClass -> Stream.of(hierarchyClass.getDeclaredFields())) + .filter(f -> f.getName().equals(fieldName)).findFirst(); + + if (fieldNameField.isPresent()) { + + if (java.lang.reflect.Modifier.isStatic(fieldNameField.get().getModifiers())) { + return unsafe.staticFieldOffset(fieldNameField.get()); + } else { + return unsafe.objectFieldOffset(fieldNameField.get()); + } + } else { + return sun.misc.Unsafe.INVALID_FIELD_OFFSET; + } + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + static final CompactMapNode allocateHeapRegion(final Class clazz) { + try { + final Object newInstance = unsafe.allocateInstance(clazz); + return (CompactMapNode) newInstance; + } catch (ClassCastException | InstantiationException e) { + throw new RuntimeException(e); + } + } + + static final CompactMapNode allocateHeapRegion(final int dim1, final int dim2) { + final Class clazz = specializationsByContentAndNodes[dim1][dim2]; + return allocateHeapRegion(clazz); + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int index, final int val) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(srcClass); + + dst.rawMap1 = rawMap1; + + dst.rawMap2 = rawMap2; + + int pIndex = TUPLE_LENGTH * index + 1; + + long offset = arrayBase; + offset += rangecopyIntRegion(src, offset, dst, offset, 2 * payloadArity); + + setInIntRegion(dst, arrayBase, pIndex, val); + + long rareBase = offset; + offset += rangecopyObjectRegion(src, offset, dst, offset, untypedSlotArity); + + /* + * final int pIndex = TUPLE_LENGTH * index + 1; + * + * rangecopyPrimitiveRegion(src, arrayBase, dst, arrayBase, primitiveRegionSize); + * setInIntRegion(dst, arrayBase, pIndex, val); + * + * rangecopyObjectRegion(src, rareBase, 0, dst, rareBase, 0, untypedSlotArity); + */ + + return dst; + } + + CompactMapNode copyAndSetRareValue(final AtomicReference mutator, final int bitpos, + final int index, final Object val) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(srcClass); + + dst.rawMap1 = rawMap1; + + dst.rawMap2 = rawMap2; + + int pIndex = TUPLE_LENGTH * index + 1; + + long offset = arrayBase; + offset += rangecopyIntRegion(src, offset, dst, offset, 2 * payloadArity); + + long rareBase = offset; + offset += rangecopyObjectRegion(src, offset, dst, offset, untypedSlotArity); + + setInObjectRegion(dst, rareBase, pIndex, val); + + /* + * final int pIndex = TUPLE_LENGTH * index + 1; + * + * rangecopyPrimitiveRegion(src, arrayBase, dst, arrayBase, primitiveRegionSize); + * + * rangecopyObjectRegion(src, rareBase, 0, dst, rareBase, 0, untypedSlotArity); + * setInObjectRegion(dst, rareBase, pIndex, val); + */ + + return dst; + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int index, final int key, final int val) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(payloadArity + 1, untypedSlotArity); + + dst.rawMap1 = rawMap1; + dst.rawMap2 = (int) (rawMap2 | bitpos); + + final int pIndex = TUPLE_LENGTH * index; + + int typedSlotArity = payloadArity * 2; + + long offset = arrayBase; + long delta = 0; + + offset += rangecopyIntRegion(src, offset, dst, offset, pIndex); + delta += setInIntRegionVarArgs(dst, offset, key, val); + offset += rangecopyIntRegion(src, offset, dst, offset + delta, typedSlotArity - pIndex); + offset += rangecopyObjectRegion(src, offset, dst, offset + delta, untypedSlotArity); + + return dst; + } + + CompactMapNode copyAndInsertRareValue(final AtomicReference mutator, final int bitpos, + final int index, final Object key, final Object val) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(payloadArity, untypedSlotArity + TUPLE_LENGTH); + + dst.rawMap1 = (int) (rawMap1 | bitpos); + dst.rawMap2 = (int) (rawMap2 | bitpos); + + final int pIndex = TUPLE_LENGTH * index; + + long offset = arrayBase; + long delta = 0; + + offset += rangecopyIntRegion(src, offset, dst, offset, 2 * payloadArity); + offset += rangecopyObjectRegion(src, offset, dst, offset, pIndex); + delta += setInObjectRegionVarArgs(dst, offset, key, val); + offset += rangecopyObjectRegion(src, offset, dst, offset + delta, untypedSlotArity - pIndex); + + return dst; + } + + // CompactMapNode copyAndInsertRareValue(final AtomicReference mutator, final int + // bitpos, + // final int index, final Object key, final Object val) { + // + // AbstractArrayView src1 = getIntArrayView(); + // AbstractArrayView src2 = getObjectArrayView(); + // + // final CompactMapNode dst = allocateHeapRegion(src1.length / 2, src2.length + TUPLE_LENGTH); + // + // dst.rawMap1 = rawMap1 | bitpos; + // dst.rawMap2 = rawMap2 | bitpos; + // + // AbstractArrayView dst1 = dst.getIntArrayView(); + // AbstractArrayView dst2 = dst.getObjectArrayView(); + // + // arrayviewcopy(src1, 0, dst1, 0, src1.length); + // + // final int idx2 = index * TUPLE_LENGTH; + // + // arrayviewcopy(src2, 0, dst2, 0, idx2); + // dst2.set(idx2 + 0, key); + // dst2.set(idx2 + 1, val); + // arrayviewcopy(src2, idx2, dst2, idx2 + TUPLE_LENGTH, src2.length - idx2); + // + // return dst; + // } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIdx = dataIndex(bitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(payloadArity - 1, untypedSlotArity); + + long srcOffset = arrayBase; + long dstOffset = arrayBase; + + dst.rawMap1 = unsafe.getInt(src, globalRawMap1Offset); + + dst.rawMap2 = (int) (unsafe.getInt(src, globalRawMap2Offset) ^ bitpos); + + for (int i = 0; i < valIdx; i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + } + srcOffset += 4; + srcOffset += 4; + for (int i = valIdx + 1; i < payloadArity(); i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + } + for (int i = 0; i < rarePayloadArity(); i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + for (int i = nodeArity() - 1; i >= 0; i--) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + + return dst; + } + + CompactMapNode copyAndRemoveRareValue(final AtomicReference mutator, final int bitpos) { + final int valIdx = rareIndex(bitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(payloadArity, untypedSlotArity - TUPLE_LENGTH); + + long srcOffset = arrayBase; + long dstOffset = arrayBase; + + dst.rawMap1 = (int) (unsafe.getInt(src, globalRawMap1Offset) ^ bitpos); + + dst.rawMap2 = (int) (unsafe.getInt(src, globalRawMap2Offset) ^ bitpos); + + for (int i = 0; i < payloadArity(); i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + } + for (int i = 0; i < valIdx; i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + srcOffset += addressSize; + srcOffset += addressSize; + for (int i = valIdx + 1; i < rarePayloadArity(); i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + for (int i = nodeArity() - 1; i >= 0; i--) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + + return dst; + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int index, + final AbstractMapNode node) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.rawMap1 = rawMap1; + dst.rawMap2 = rawMap2; + + /* + * rangecopyPrimitiveRegion(src, arrayBase, dst, arrayBase, primitiveRegionSize); + * + * rangecopyObjectRegion(src, rareBase, 0, dst, rareBase, 0, untypedSlotArity); + * setInObjectRegion(dst, rareBase, untypedSlotArity - 1 - index, node); + */ + + int pIndex = untypedSlotArity - 1 - index; + + long offset = arrayBase; + offset += rangecopyIntRegion(src, offset, dst, offset, 2 * payloadArity); + + long rareBase = offset; + offset += rangecopyObjectRegion(src, offset, dst, offset, untypedSlotArity); + + setInObjectRegion(dst, rareBase, pIndex, node); + + return dst; + } + + // CompactMapNode copyAndSetNode(final AtomicReference mutator, final int index, + // final AbstractMapNode node) { + // + // AbstractArrayView src1 = getIntArrayView(); + // AbstractArrayView src2 = getObjectArrayView(); + // + // final CompactMapNode dst = allocateHeapRegion(getClass()); + // + // dst.rawMap1 = rawMap1; + // dst.rawMap2 = rawMap2; + // + // AbstractArrayView dst1 = dst.getIntArrayView(); + // AbstractArrayView dst2 = dst.getObjectArrayView(); + // + // arrayviewcopy(src1, 0, dst1, 0, src1.length); + // + // final int idx2 = src2.length - 1 - index; + // + // arrayviewcopy(src2, 0, dst2, 0, src2.length); + // dst2.set(idx2, node); + // + // return dst; + // } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final int indexOld, final int indexNew, final AbstractMapNode node) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(payloadArity - 1, untypedSlotArity + 1); + + // idempotent operation; in case of rare bit was already set before + dst.rawMap1 = (int) (rawMap1 | bitpos); + dst.rawMap2 = (int) (rawMap2 ^ bitpos); + + final int pIndexOld = TUPLE_LENGTH * indexOld; + final int pIndexNew = (untypedSlotArity + 1) - 1 - indexNew; + + long offset = arrayBase; + offset += rangecopyIntRegion(src, offset, dst, offset, pIndexOld); + long delta = 2 * 4 /* sizeOfInt() */; + offset += rangecopyIntRegion(src, offset + delta, dst, offset, + (TUPLE_LENGTH * (payloadArity - 1) - pIndexOld)); + + offset += rangecopyObjectRegion(src, offset + delta, dst, offset, pIndexNew); + long delta2 = setInObjectRegionVarArgs(dst, offset, node); + delta -= delta2; + offset += delta2; + offset += + rangecopyObjectRegion(src, offset + delta, dst, offset, untypedSlotArity - pIndexNew); + + return dst; + } + + CompactMapNode copyAndMigrateFromRareInlineToNode(final AtomicReference mutator, + final int bitpos, final int indexOld, final int indexNew, final AbstractMapNode node) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = + allocateHeapRegion(payloadArity, untypedSlotArity - TUPLE_LENGTH + 1); + + // idempotent operation; in case of rare bit was already set before + dst.rawMap1 = (int) (rawMap1 | bitpos); + dst.rawMap2 = (int) (rawMap2 ^ bitpos); + + final int pIndexOld = TUPLE_LENGTH * indexOld; + final int pIndexNew = (untypedSlotArity - TUPLE_LENGTH + 1) - 1 - indexNew; + + long offset = arrayBase; + offset += rangecopyIntRegion(src, arrayBase, dst, arrayBase, 2 * payloadArity); + + offset += rangecopyObjectRegion(src, offset, dst, offset, pIndexOld); + long delta = 2 * sizeOfObject(); + offset += rangecopyObjectRegion(src, offset + delta, dst, offset, pIndexNew - pIndexOld); + long delta2 = setInObjectRegionVarArgs(dst, offset, node); + delta -= delta2; + offset += delta2; + offset += + rangecopyObjectRegion(src, offset + delta, dst, offset, untypedSlotArity - pIndexNew - 2); + + return dst; + } + + // // TODO: code ~25ms slower than code above + // CompactMapNode copyAndMigrateFromRareInlineToNode(final AtomicReference mutator, + // final int bitpos, final int indexOld, final int indexNew, final AbstractMapNode node) { + // + // AbstractArrayView src1 = getIntArrayView(); + // AbstractArrayView src2 = getObjectArrayView(); + // + // final CompactMapNode dst = allocateHeapRegion(src1.length / 2, src2.length - TUPLE_LENGTH + + // 1); + // + // dst.rawMap1 = rawMap1 | bitpos; + // dst.rawMap2 = rawMap2 ^ bitpos; + // + // AbstractArrayView dst1 = dst.getIntArrayView(); + // AbstractArrayView dst2 = dst.getObjectArrayView(); + // + // arrayviewcopy(src1, 0, dst1, 0, src1.length); + // + // final int idxOld2 = indexOld * TUPLE_LENGTH; + // final int idxNew2 = dst2.length - 1 - indexNew; + // + // arrayviewcopy(src2, 0, dst2, 0, idxOld2); + // arrayviewcopy(src2, idxOld2 + TUPLE_LENGTH, dst2, idxOld2, idxNew2 - idxOld2); + // dst2.set(idxNew2, node); + // arrayviewcopy(src2, idxNew2 + TUPLE_LENGTH, dst2, idxNew2 + 1, src2.length - idxNew2 - + // TUPLE_LENGTH); + // + // return dst; + // } + + // // TODO: code ~XXms slower than code above + // CompactMapNode copyAndMigrateFromRareInlineToNode(final AtomicReference mutator, + // final int bitpos, final int indexOld, final int indexNew, final AbstractMapNode node) { + // + // AbstractArrayView src1 = getIntArrayView(); + // ObjectArrayView src2 = getObjectArrayView(); + // + // final CompactMapNode dst = + // allocateHeapRegion(src1.length / 2, src2.length - TUPLE_LENGTH + 1); + // + // dst.rawMap1 = rawMap1 | bitpos; + // dst.rawMap2 = rawMap2 ^ bitpos; + // + // AbstractArrayView dst1 = dst.getIntArrayView(); + // ObjectArrayView dst2 = dst.getObjectArrayView(); + // + // arrayviewcopy(src1, 0, dst1, 0, src1.length); + // + // final int idxOld2 = indexOld * TUPLE_LENGTH; + // final int idxNew2 = dst2.length - 1 - indexNew; + // + // /***************/ + // + //// arrayviewcopy(src2, 0, dst2, 0, idxOld2); + //// arrayviewcopy(src2, idxOld2 + TUPLE_LENGTH, dst2, idxOld2, idxNew2 - idxOld2); + //// dst2.set(idxNew2, node); + //// arrayviewcopy(src2, idxNew2 + TUPLE_LENGTH, dst2, idxNew2 + 1, + //// src2.length - idxNew2 - TUPLE_LENGTH); + // + // /***************/ + // + //// long offset = src1.offset; + //// + //// offset += rangecopyObjectRegion(src2.base, offset, dst2.base, offset, idxOld2); + //// offset += rangecopyObjectRegion(src2.base, offset + sizeOfObject() * TUPLE_LENGTH, + // dst2.base, offset, idxNew2 - idxOld2); + //// offset += setInObjectRegionVarArgs(dst2.base, offset, node); + //// offset += rangecopyObjectRegion(src2.base, offset + sizeOfObject(), dst2.base, offset, + // src2.length - idxNew2 - TUPLE_LENGTH); + // + // /***************/ + // + // StreamingCopy sc = StreamingCopy.streamingCopyTwoOffsets(src2, dst2); + // + // sc.copy(idxOld2); + // sc.skipAtSrc(TUPLE_LENGTH); + // sc.copy(idxNew2 - idxOld2); + // sc.insert(node); + // sc.copy(src2.length - idxNew2 - TUPLE_LENGTH); + // + //// sc.copy(idxOld2); + //// sc.copyWithSrcForward(idxNew2 - idxOld2, TUPLE_LENGTH); + //// sc.insert(node); + //// sc.copyWithSrcForward(src2.length - idxNew2 - TUPLE_LENGTH, TUPLE_LENGTH); + // + //// StreamingCopy sc = StreamingCopy.streamingCopyOneOffset(src2, dst2); + //// + //// sc.copy(idxOld2); + //// sc.copyWithSrcForward(idxNew2 - idxOld2, TUPLE_LENGTH); + //// sc.put(node); + //// sc.copyWithSrcDstForward(src2.length - idxNew2 - TUPLE_LENGTH, TUPLE_LENGTH, 1); + // + // return dst; + // } + + // CompactMapNode copyAndMigrateFromRareInlineToNode(final AtomicReference mutator, + // final int bitpos, final int indexOld, final int indexNew, final AbstractMapNode node) { + // final Class srcClass = this.getClass(); + // + // final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + // final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + // + // final CompactMapNode src = this; + // final CompactMapNode dst = + // allocateHeapRegion(payloadArity, untypedSlotArity - TUPLE_LENGTH + 1); + // + // // idempotent operation; in case of rare bit was already set before + // dst.rawMap1 = (int) (rawMap1 | bitpos); + // dst.rawMap2 = (int) (rawMap2 ^ bitpos); + // + // final int pIndexOld = TUPLE_LENGTH * indexOld; + // final int pIndexNew = (untypedSlotArity - TUPLE_LENGTH + 1) - 1 - indexNew; + // + // long offset = arrayBase; + // offset += rangecopyIntRegion(src, arrayBase, dst, arrayBase, 2 * payloadArity); + // + // offset += rangecopyObjectRegion(src, offset, dst, offset, pIndexOld); + // long delta = 2 * sizeOfObject(); + // offset += rangecopyObjectRegion(src, offset + delta, dst, offset, pIndexNew - pIndexOld); + // long delta2 = setInObjectRegionVarArgs(dst, offset, node); + // delta -= delta2; + // offset += delta2; + // offset += + // rangecopyObjectRegion(src, offset + delta, dst, offset, untypedSlotArity - pIndexNew - 2); + // + // return dst; + // } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final AbstractMapNode node) { + final int idxOld = nodeIndex(bitpos); + final int idxNew = dataIndex(bitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = + allocateHeapRegion(payloadArity + 1, untypedSlotArity - TUPLE_LENGTH); + + long srcOffset = arrayBase; + long dstOffset = arrayBase; + + // idempotent operation; in case of rare bit was already set before + dst.rawMap1 = (int) (unsafe.getInt(src, globalRawMap1Offset) ^ bitpos); + + dst.rawMap2 = (int) (unsafe.getInt(src, globalRawMap2Offset) | bitpos); + + for (int i = 0; i < idxNew; i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + } + unsafe.putInt(dst, dstOffset, node.getKey(0)); + dstOffset += 4; + unsafe.putInt(dst, dstOffset, node.getVal(0)); + dstOffset += 4; + for (int i = idxNew; i < payloadArity(); i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + } + for (int i = 0; i < rarePayloadArity(); i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + for (int i = nodeArity() - 1; i >= idxOld + 1; i--) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + srcOffset += addressSize; + for (int i = idxOld - 1; i >= 0; i--) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + + return dst; + } + + CompactMapNode copyAndMigrateFromNodeToRareInline(final AtomicReference mutator, + final int bitpos, final AbstractMapNode node) { + final int idxOld = nodeIndex(bitpos); + final int idxNew = rareIndex(bitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = + allocateHeapRegion(payloadArity, untypedSlotArity + TUPLE_LENGTH - 1); + + long srcOffset = arrayBase; + long dstOffset = arrayBase; + + // idempotent operation; in case of rare bit was already set before + dst.rawMap1 = (int) (unsafe.getInt(src, globalRawMap1Offset) | bitpos); + + dst.rawMap2 = (int) (unsafe.getInt(src, globalRawMap2Offset) | bitpos); + + for (int i = 0; i < payloadArity(); i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + } + for (int i = 0; i < idxNew; i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + unsafe.putObject(dst, dstOffset, node.getRareKey(0)); + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, node.getRareVal(0)); + dstOffset += addressSize; + for (int i = idxNew; i < rarePayloadArity(); i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + for (int i = nodeArity() - 1; i >= idxOld + 1; i--) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + srcOffset += addressSize; + for (int i = idxOld - 1; i >= 0; i--) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + + return dst; + } + + static final AbstractMapNode mergeTwoKeyValPairs(final Object key0, final Object val0, + final int keyHash0, final Object key1, final Object val1, final int keyHash1, + final int shift) { + // assert !(key0 == key1); + + if (shift >= hashCodeLength()) { + return new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(keyHash0, + (Object[]) new Object[]{key0, key1}, (Object[]) new Object[]{val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int nodeMap = (int) (bitpos(mask0) | bitpos(mask1)); + final int dataMap = (int) (bitpos(mask0) | bitpos(mask1)); + + if (mask0 < mask1) { + return nodeOf4x0(null, (int) nodeMap, dataMap, key0, val0, key1, val1); + } else { + return nodeOf4x0(null, (int) nodeMap, dataMap, key1, val1, key0, val0); + } + } else { + final AbstractMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, keyHash1, + shift + bitPartitionSize()); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf1x0(null, nodeMap, (int) 0, node); + } + } + + static final AbstractMapNode mergeTwoKeyValPairs(final Object key0, final Object val0, + final int keyHash0, final int key1, final int val1, final int keyHash1, final int shift) { + // assert !(key0 == key1); + + if (shift >= hashCodeLength()) { + return new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(keyHash0, + (Object[]) new Object[]{key0, key1}, (Object[]) new Object[]{val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int nodeMap = (int) (bitpos(mask0)); + final int dataMap = (int) (bitpos(mask0) | bitpos(mask1)); + + // convention: rare after base + return nodeOf2x1(null, (int) nodeMap, dataMap, key1, val1, key0, val0); + } else { + final AbstractMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, keyHash1, + shift + bitPartitionSize()); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf1x0(null, nodeMap, (int) 0, node); + } + } + + static final AbstractMapNode mergeTwoKeyValPairs(final int key0, final int val0, + final int keyHash0, final Object key1, final Object val1, final int keyHash1, + final int shift) { + // assert !(key0 == key1); + + if (shift >= hashCodeLength()) { + return new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(keyHash0, + (Object[]) new Object[]{key0, key1}, (Object[]) new Object[]{val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int nodeMap = (int) (bitpos(mask1)); + final int dataMap = (int) (bitpos(mask0) | bitpos(mask1)); + + // convention: rare after base + return nodeOf2x1(null, (int) nodeMap, dataMap, key0, val0, key1, val1); + } else { + final AbstractMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, keyHash1, + shift + bitPartitionSize()); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf1x0(null, nodeMap, (int) 0, node); + } + } + + static final AbstractMapNode mergeTwoKeyValPairs(final int key0, final int val0, + final int keyHash0, final int key1, final int val1, final int keyHash1, final int shift) { + // assert !(key0 == key1); + + if (shift >= hashCodeLength()) { + return new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(keyHash0, + (Object[]) new Object[]{key0, key1}, (Object[]) new Object[]{val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int nodeMap = 0; + final int dataMap = (int) (bitpos(mask0) | bitpos(mask1)); + + if (mask0 < mask1) { + return nodeOf0x2(null, (int) nodeMap, dataMap, key0, val0, key1, val1); + } else { + return nodeOf0x2(null, (int) nodeMap, dataMap, key1, val1, key0, val0); + } + } else { + final AbstractMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, keyHash1, + shift + bitPartitionSize()); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf1x0(null, nodeMap, (int) 0, node); + } + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + int rareIndex(final int bitpos) { + return java.lang.Integer.bitCount(rareMap() & (bitpos - 1)); + } + + AbstractMapNode nodeAt(final int bitpos) { + return getNode(nodeIndex(bitpos)); + } + + private static final boolean equals(final Object o1, final Object o2) { + if (null == o1 || null == o2) { + return false; + } + if (o1 == o2) { + return true; + } + if (o1.getClass() != o2.getClass()) { + return false; + } + + final CompactMapNode src = (CompactMapNode) o1; + final CompactMapNode dst = (CompactMapNode) o2; + + final Class clazz = o1.getClass(); + final long[] arrayOffsets = (long[]) unsafe.getObject(clazz, globalArrayOffsetsOffset); + + // compare rawMap1 + if (!(unsafe.getInt(src, globalRawMap1Offset) == unsafe.getInt(dst, globalRawMap1Offset))) { + return false; + } + + // compare rawMap2 + if (!(unsafe.getInt(src, globalRawMap2Offset) == unsafe.getInt(dst, globalRawMap2Offset))) { + return false; + } + + // compare payload range + for (int i = 0; i < src.payloadArity(); i++) { + if (!(unsafe.getInt(src, + arrayOffsets[src.logicalToPhysicalIndex(ContentType.KEY, i)]) == unsafe.getInt(dst, + arrayOffsets[dst.logicalToPhysicalIndex(ContentType.KEY, i)]))) { + return false; + } + + if (!(unsafe.getInt(src, + arrayOffsets[src.logicalToPhysicalIndex(ContentType.VAL, i)]) == unsafe.getInt(dst, + arrayOffsets[dst.logicalToPhysicalIndex(ContentType.VAL, i)]))) { + return false; + } + } + + // compare node range + for (int i = 0; i < src.nodeArity(); i++) { + if (!(unsafe.getObject(src, arrayOffsets[src.logicalToPhysicalIndex(ContentType.NODE, i)]) + .equals(unsafe.getObject(dst, + arrayOffsets[dst.logicalToPhysicalIndex(ContentType.NODE, i)])))) { + return false; + } + } + + return true; + } + + static final byte recoverMask(int map, final byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = (int) (map >> 1); + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getKey(i)), + Objects.hashCode(getVal(i)))); + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + bldr.append(']'); + return bldr.toString(); + } + + static final AbstractMapNode nodeOf1x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object slot0) { + return new Map0To1Node_5Bits_Heterogeneous_BleedingEdge(mutator, nodeMap, dataMap, slot0); + } + + static final AbstractMapNode nodeOf0x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1) { + return new Map1To0Node_5Bits_Heterogeneous_BleedingEdge(mutator, nodeMap, dataMap, key1, + val1); + } + + static final AbstractMapNode nodeOf0x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2) { + return new Map2To0Node_5Bits_Heterogeneous_BleedingEdge(mutator, nodeMap, dataMap, key1, val1, + key2, val2); + } + + static final AbstractMapNode nodeOf4x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + return new Map0To4Node_5Bits_Heterogeneous_BleedingEdge(mutator, nodeMap, dataMap, slot0, + slot1, slot2, slot3); + } + + static final AbstractMapNode nodeOf2x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object slot0, final Object slot1) { + return new Map0To2Node_5Bits_Heterogeneous_BleedingEdge(mutator, nodeMap, dataMap, slot0, + slot1); + } + + static final AbstractMapNode nodeOf2x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final Object slot0, final Object slot1) { + return new Map1To2Node_5Bits_Heterogeneous_BleedingEdge(mutator, nodeMap, dataMap, key1, val1, + slot0, slot1); + } + + @Override + boolean containsKeyEquivalent(final int key, final int keyHash, final int shift, + final Comparator cmp) { + CompactMapNode instance = this; + Class clazz = instance.getClass(); + + for (int shift0 = shift; true; shift0 += bitPartitionSize()) { + final int mask = mask(keyHash, shift0); + final int bitpos = bitpos(mask); + + final int nodeMap = instance.nodeMap(); + // final int nodeMap = unsafe.getInt(instance, globalRawMap1Offset); + if (isBitInBitmap(nodeMap, bitpos)) { + final int index = index(nodeMap, mask, bitpos); + final AbstractMapNode nestedInstance = getNode(clazz, instance, index); + + try { + instance = (CompactMapNode) nestedInstance; + clazz = instance.getClass(); + } catch (ClassCastException unused) { + return ((HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge) nestedInstance) + .containsKey(key, keyHash, 0); + } + } else { + final int dataMap = instance.dataMap(); + // final int dataMap = unsafe.getInt(instance, globalRawMap2Offset); + if (isBitInBitmap(dataMap, bitpos)) { + final int index = index(dataMap, mask, bitpos); + return getKey(clazz, instance, index) == key; + } else { + return false; + } + } + } + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + int rawMap1 = this.rawMap1; + int rawMap2 = this.rawMap2; + + final int rareMap = (int) (rawMap1 & rawMap2); + final int dataMap = (int) (rawMap2 ^ rareMap); + final int nodeMap = (int) (rawMap1 ^ rareMap); + + final int nodeIndex = index(nodeMap, mask, bitpos); + + // check for node (not value) + if (isBitInBitmap(nodeMap, bitpos)) { + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + bitPartitionSize(), details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } else + // check for inplace (rare) value + if (isBitInBitmap(rareMap, bitpos)) { + final int rareIndex = index(rareMap, mask, bitpos); + final Object currentKey = getRareKey(rareIndex); + + final Object currentVal = getRareVal(rareIndex); + + final AbstractMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromRareInlineToNode(mutator, bitpos, rareIndex, nodeIndex, + subNodeNew); + + } else + // check for inplace value + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + final int currentVal = getVal(dataIndex); + + // update mapping + details.updated(EitherIntOrObject.ofInt(currentVal)); + return copyAndSetValue(mutator, bitpos, dataIndex, val); + } else { + final int currentVal = getVal(dataIndex); + + final AbstractMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey), key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, dataIndex, nodeIndex, + subNodeNew); + } + + } else { + // no value + details.modified(); + int dataIndex = index(dataMap, mask, bitpos); + return copyAndInsertValue(mutator, bitpos, dataIndex, key, val); + } + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + int rawMap1 = this.rawMap1; + int rawMap2 = this.rawMap2; + + final int rareMap = (int) (rawMap1 & rawMap2); + final int dataMap = (int) (rawMap2 ^ rareMap); + final int nodeMap = (int) (rawMap1 ^ rareMap); + + final int nodeIndex = index(nodeMap, mask, bitpos); + + // check for node (not value) + if (isBitInBitmap(nodeMap, bitpos)) { + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + bitPartitionSize(), details); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } else + // check for inplace (rare) value + if (isBitInBitmap(rareMap, bitpos)) { + final int rareIndex = index(rareMap, mask, bitpos); + final Object currentKey = getRareKey(rareIndex); + + final Object currentVal = getRareVal(rareIndex); + + final AbstractMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromRareInlineToNode(mutator, bitpos, rareIndex, nodeIndex, + subNodeNew); + + } else + // check for inplace value + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + final int currentVal = getVal(dataIndex); + + // update mapping + details.updated(EitherIntOrObject.ofInt(currentVal)); + return copyAndSetValue(mutator, bitpos, dataIndex, val); + } else { + final int currentVal = getVal(dataIndex); + + final AbstractMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey), key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, dataIndex, nodeIndex, + subNodeNew); + } + + } else { + // no value + details.modified(); + int dataIndex = index(dataMap, mask, bitpos); + return copyAndInsertValue(mutator, bitpos, dataIndex, key, val); + } + } + + @Override + Map.Entry getKeyValueEntry(final int index) { + return entryOf(getKey(index), getVal(index)); + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final Object key, + final Object val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + int rawMap1 = this.rawMap1; + int rawMap2 = this.rawMap2; + + final int rareMap = (int) (rawMap1 & rawMap2); + final int dataMap = (int) (rawMap2 ^ rareMap); + final int nodeMap = (int) (rawMap1 ^ rareMap); + + final int nodeIndex = index(nodeMap, mask, bitpos); + + // check for node (not value) + if (isBitInBitmap(nodeMap, bitpos)) { + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + bitPartitionSize(), details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } else + // check for inplace (rare) value + if (isBitInBitmap(rareMap, bitpos)) { + final int rareIndex = index(rareMap, mask, bitpos); + final Object currentKey = getRareKey(rareIndex); + + if (cmp.compare(currentKey, key) == 0) { + final Object currentVal = getRareVal(rareIndex); + + // update mapping + details.updated(EitherIntOrObject.ofObject(currentVal)); + return copyAndSetRareValue(mutator, bitpos, rareIndex, val); + } else { + final Object currentVal = getRareVal(rareIndex); + + final AbstractMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromRareInlineToNode(mutator, bitpos, rareIndex, nodeIndex, + subNodeNew); + } + + } else + // check for inplace value + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final int currentKey = getKey(dataIndex); + + final int currentVal = getVal(dataIndex); + + final AbstractMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey), key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, dataIndex, nodeIndex, + subNodeNew); + + } else { + // no value + details.modified(); + int rareIndex = index(rareMap, mask, bitpos); + return copyAndInsertRareValue(mutator, bitpos, rareIndex, key, val); + } + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final Object key, + final Object val, final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + int rawMap1 = this.rawMap1; + int rawMap2 = this.rawMap2; + + final int rareMap = (int) (rawMap1 & rawMap2); + final int dataMap = (int) (rawMap2 ^ rareMap); + final int nodeMap = (int) (rawMap1 ^ rareMap); + + final int nodeIndex = index(nodeMap, mask, bitpos); + + // check for node (not value) + if (isBitInBitmap(nodeMap, bitpos)) { + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + bitPartitionSize(), details); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } else + // check for inplace (rare) value + if (isBitInBitmap(rareMap, bitpos)) { + final int rareIndex = index(rareMap, mask, bitpos); + final Object currentKey = getRareKey(rareIndex); + + if (currentKey.equals(key)) { + final Object currentVal = getRareVal(rareIndex); + + // update mapping + details.updated(EitherIntOrObject.ofObject(currentVal)); + return copyAndSetRareValue(mutator, bitpos, rareIndex, val); + } else { + final Object currentVal = getRareVal(rareIndex); + + final AbstractMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromRareInlineToNode(mutator, bitpos, rareIndex, nodeIndex, + subNodeNew); + } + + } else + // check for inplace value + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final int currentKey = getKey(dataIndex); + + final int currentVal = getVal(dataIndex); + + final AbstractMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey), key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, dataIndex, nodeIndex, + subNodeNew); + + } else { + // no value + details.modified(); + int rareIndex = index(rareMap, mask, bitpos); + return copyAndInsertRareValue(mutator, bitpos, rareIndex, key, val); + } + } + + @Override + Optional findByKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = this.dataMap(); + if (isBitInBitmap(dataMap, bitpos)) { // inplace value + final int index = index(dataMap, mask, bitpos); + + if (getKey(index) == key) { + final Object result = getVal(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + bitPartitionSize(), cmp); + } + + return Optional.empty(); + } + + @Override + int getKey(final int index) { + return getKey(this.getClass(), this, index); + } + + @Override + Object getRareKey(final int index) { + return getRareKey(this.getClass(), this, index); + } + + @Override + boolean containsKeyEquivalent(final Object key, final int keyHash, final int shift, + final Comparator cmp) { + CompactMapNode instance = this; + Class clazz = instance.getClass(); + + for (int shift0 = shift; true; shift0 += bitPartitionSize()) { + final int mask = mask(keyHash, shift0); + final int bitpos = bitpos(mask); + + final int nodeMap = instance.nodeMap(); + // final int nodeMap = unsafe.getInt(instance, globalRawMap1Offset); + if (isBitInBitmap(nodeMap, bitpos)) { + final int index = index(nodeMap, mask, bitpos); + final AbstractMapNode nestedInstance = getNode(clazz, instance, index); + + try { + instance = (CompactMapNode) nestedInstance; + clazz = instance.getClass(); + } catch (ClassCastException unused) { + return ((HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge) nestedInstance) + .containsKey(key, keyHash, 0); + } + } else { + final int rareMap = instance.rareMap(); + // final int rareMap = unsafe.getInt(instance, globalRawMap2Offset); + if (isBitInBitmap(rareMap, bitpos)) { + final int index = index(rareMap, mask, bitpos); + return cmp.compare(getRareKey(clazz, instance, index), key) == 0; + } else { + return false; + } + } + } + } + + @Override + boolean containsKey(final int key, final int keyHash, final int shift) { + CompactMapNode instance = this; + Class clazz = instance.getClass(); + + for (int shift0 = shift; true; shift0 += bitPartitionSize()) { + final int mask = mask(keyHash, shift0); + final int bitpos = bitpos(mask); + + final int nodeMap = instance.nodeMap(); + // final int nodeMap = unsafe.getInt(instance, globalRawMap1Offset); + if (isBitInBitmap(nodeMap, bitpos)) { + final int index = index(nodeMap, mask, bitpos); + final AbstractMapNode nestedInstance = getNode(clazz, instance, index); + + try { + instance = (CompactMapNode) nestedInstance; + clazz = instance.getClass(); + } catch (ClassCastException unused) { + return ((HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge) nestedInstance) + .containsKey(key, keyHash, 0); + } + } else { + final int dataMap = instance.dataMap(); + // final int dataMap = unsafe.getInt(instance, globalRawMap2Offset); + if (isBitInBitmap(dataMap, bitpos)) { + final int index = index(dataMap, mask, bitpos); + return getKey(clazz, instance, index) == key; + } else { + return false; + } + } + } + } + + @Override + int untypedSlotArity() { + return unsafe.getInt(this.getClass(), globalUntypedSlotArityOffset); + } + + @Override + Optional findByKey(final Object key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int rareMap = this.rareMap(); + if (isBitInBitmap(rareMap, bitpos)) { // inplace value + final int index = index(rareMap, mask, bitpos); + + if (cmp.compare(getRareKey(index), key) == 0) { + final Object result = getRareVal(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + bitPartitionSize(), cmp); + } + + return Optional.empty(); + } + + @Override + Optional findByKey(final int key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = this.dataMap(); + if (isBitInBitmap(dataMap, bitpos)) { // inplace value + final int index = index(dataMap, mask, bitpos); + + if (getKey(index) == key) { + final Object result = getVal(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + bitPartitionSize()); + } + + return Optional.empty(); + } + + @Override + boolean containsKey(final Object key, final int keyHash, final int shift) { + CompactMapNode instance = this; + Class clazz = instance.getClass(); + + for (int shift0 = shift; true; shift0 += bitPartitionSize()) { + final int mask = mask(keyHash, shift0); + final int bitpos = bitpos(mask); + + final int nodeMap = instance.nodeMap(); + // final int nodeMap = unsafe.getInt(instance, globalRawMap1Offset); + if (isBitInBitmap(nodeMap, bitpos)) { + final int index = index(nodeMap, mask, bitpos); + final AbstractMapNode nestedInstance = getNode(clazz, instance, index); + + try { + instance = (CompactMapNode) nestedInstance; + clazz = instance.getClass(); + } catch (ClassCastException unused) { + return ((HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge) nestedInstance) + .containsKey(key, keyHash, 0); + } + } else { + final int rareMap = instance.rareMap(); + // final int rareMap = unsafe.getInt(instance, globalRawMap2Offset); + if (isBitInBitmap(rareMap, bitpos)) { + final int index = index(rareMap, mask, bitpos); + return getRareKey(clazz, instance, index).equals(key); + } else { + return false; + } + } + } + } + + @Override + Object getSlot(final int index) { + try { + final long[] arrayOffsets = + (long[]) unsafe.getObject(this.getClass(), globalArrayOffsetsOffset); + return (Object) unsafe.getObject(this, + arrayOffsets[logicalToPhysicalIndex(ContentType.SLOT, index)]); + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + @Override + int payloadArity() { + return unsafe.getInt(this.getClass(), globalPayloadArityOffset); + } + + @Override + boolean hasPayload() { + return payloadArity() != 0; + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + // TODO: generalize bitmap declaration/if/index assignment in code generator pattern + // check for inplace value + final int dataMap = dataMap(); + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + final int currentVal = getVal(dataIndex); + details.updated(EitherIntOrObject.ofInt(currentVal)); + + /* + * Case payload == 2: Create new node with remaining pair. The new node will a) either + * become the new root returned, or b) unwrapped and inlined during returning. + */ + if (this.payloadArity() == 2 && this.rarePayloadArity() == 0 && this.nodeArity() == 0) { + final int newRawMap = + (shift == 0) ? (int) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf0x1(mutator, newRawMap, newRawMap, getKey(1 - dataIndex), + getVal(1 - dataIndex)); + } else if (this.payloadArity() == 1 && this.rarePayloadArity() == 1 + && this.nodeArity() == 0) { + final int newRawMap = + (shift == 0) ? (int) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf2x0(mutator, (int) (0), newRawMap, getRareKey(0), getRareVal(0)); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } + + // check for node (not value) + final int nodeMap = nodeMap(); + if (isBitInBitmap(nodeMap, bitpos)) { + final int nodeIndex = index(nodeMap, mask, bitpos); + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + bitPartitionSize(), details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + if (payloadArity() == 1) { + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToRareInline(mutator, bitpos, subNodeNew); + } + + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + + // no value + return this; + } + + @Override + Optional findByKey(final Object key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int rareMap = this.rareMap(); + if (isBitInBitmap(rareMap, bitpos)) { // inplace value + final int index = index(rareMap, mask, bitpos); + + if (getRareKey(index).equals(key)) { + final Object result = getRareVal(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + bitPartitionSize()); + } + + return Optional.empty(); + } + + @Override + boolean hasNodes() { + return nodeArity() != 0; + } + + @Override + Object getRareVal(final int index) { + return getRareVal(this.getClass(), this, index); + } + + @Override + int rarePayloadArity() { + return Integer.bitCount(rareMap()); + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final Object key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + // TODO: generalize bitmap declaration/if/index assignment in code generator pattern + // check for inplace (rare) value + final int rareMap = rareMap(); + if (isBitInBitmap(rareMap, bitpos)) { + final int rareIndex = index(rareMap, mask, bitpos); + final Object currentKey = getRareKey(rareIndex); + + if (cmp.compare(currentKey, key) == 0) { + final Object currentVal = getRareVal(rareIndex); + details.updated(EitherIntOrObject.ofObject(currentVal)); + + /* + * Case payload == 2: Create new node with remaining pair. The new node will a) either + * become the new root returned, or b) unwrapped and inlined during returning. + */ + if (this.payloadArity() == 0 && this.rarePayloadArity() == 2 && this.nodeArity() == 0) { + final int newRawMap = + (shift == 0) ? (int) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf2x0(mutator, newRawMap, newRawMap, getRareKey(1 - rareIndex), + getRareVal(1 - rareIndex)); + } else if (this.payloadArity() == 1 && this.rarePayloadArity() == 1 + && this.nodeArity() == 0) { + final int newRawMap = + (shift == 0) ? (int) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf0x1(mutator, (int) (0), newRawMap, getKey(0), getVal(0)); + } else { + return copyAndRemoveRareValue(mutator, bitpos); + } + } else { + return this; + } + } + + // check for node (not value) + final int nodeMap = nodeMap(); + if (isBitInBitmap(nodeMap, bitpos)) { + final int nodeIndex = index(nodeMap, mask, bitpos); + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + bitPartitionSize(), details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + if (payloadArity() == 1) { + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToRareInline(mutator, bitpos, subNodeNew); + } + + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + + // no value + return this; + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + // TODO: generalize bitmap declaration/if/index assignment in code generator pattern + // check for inplace value + final int dataMap = dataMap(); + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + final int currentVal = getVal(dataIndex); + details.updated(EitherIntOrObject.ofInt(currentVal)); + + /* + * Case payload == 2: Create new node with remaining pair. The new node will a) either + * become the new root returned, or b) unwrapped and inlined during returning. + */ + if (this.payloadArity() == 2 && this.rarePayloadArity() == 0 && this.nodeArity() == 0) { + final int newRawMap = + (shift == 0) ? (int) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf0x1(mutator, newRawMap, newRawMap, getKey(1 - dataIndex), + getVal(1 - dataIndex)); + } else if (this.payloadArity() == 1 && this.rarePayloadArity() == 1 + && this.nodeArity() == 0) { + final int newRawMap = + (shift == 0) ? (int) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf2x0(mutator, (int) (0), newRawMap, getRareKey(0), getRareVal(0)); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } + + // check for node (not value) + final int nodeMap = nodeMap(); + if (isBitInBitmap(nodeMap, bitpos)) { + final int nodeIndex = index(nodeMap, mask, bitpos); + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + bitPartitionSize(), details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + if (payloadArity() == 1) { + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToRareInline(mutator, bitpos, subNodeNew); + } + + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + + // no value + return this; + } + + @Override + boolean hasSlots() { + return slotArity() != 0; + } + + @Override + int nodeArity() { + return Integer.bitCount(nodeMap()); + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final Object key, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + // TODO: generalize bitmap declaration/if/index assignment in code generator pattern + // check for inplace (rare) value + final int rareMap = rareMap(); + if (isBitInBitmap(rareMap, bitpos)) { + final int rareIndex = index(rareMap, mask, bitpos); + final Object currentKey = getRareKey(rareIndex); + + if (currentKey.equals(key)) { + final Object currentVal = getRareVal(rareIndex); + details.updated(EitherIntOrObject.ofObject(currentVal)); + + /* + * Case payload == 2: Create new node with remaining pair. The new node will a) either + * become the new root returned, or b) unwrapped and inlined during returning. + */ + if (this.payloadArity() == 0 && this.rarePayloadArity() == 2 && this.nodeArity() == 0) { + final int newRawMap = + (shift == 0) ? (int) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf2x0(mutator, newRawMap, newRawMap, getRareKey(1 - rareIndex), + getRareVal(1 - rareIndex)); + } else if (this.payloadArity() == 1 && this.rarePayloadArity() == 1 + && this.nodeArity() == 0) { + final int newRawMap = + (shift == 0) ? (int) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf0x1(mutator, (int) (0), newRawMap, getKey(0), getVal(0)); + } else { + return copyAndRemoveRareValue(mutator, bitpos); + } + } else { + return this; + } + } + + // check for node (not value) + final int nodeMap = nodeMap(); + if (isBitInBitmap(nodeMap, bitpos)) { + final int nodeIndex = index(nodeMap, mask, bitpos); + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + bitPartitionSize(), details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + if (payloadArity() == 1) { + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToRareInline(mutator, bitpos, subNodeNew); + } + + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + + // no value + return this; + } + + @Override + int slotArity() { + return unsafe.getInt(this.getClass(), globalSlotArityOffset); + } + + @Override + public boolean equals(final Object other) { + return equals(this, other); + } + + @Override + int getVal(final int index) { + return getVal(this.getClass(), this, index); + } + + @Override + AbstractMapNode getNode(final int index) { + return getNode(this.getClass(), this, index); + } + } + + private static class HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge + extends AbstractMapNode { + + final int hash; + final Object[] keys; + final Object[] vals; + + private HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(final int hash, + final Object[] keys, final Object[] vals) { + this.hash = hash; + this.keys = keys; + this.vals = vals; + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final Object currentVal = vals[idx]; + + if (cmp.compare(currentVal, val) == 0) { + return this; + } else { + // add new mapping + final Object[] src = this.vals; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final AbstractMapNode thisNew = + new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(this.hash, this.keys, + dst); + + details.updated(EitherIntOrObject.ofObject(currentVal)); + return thisNew; + } + } + } + + final Object[] keysNew = (Object[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final Object[] valsNew = (Object[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(keyHash, keysNew, valsNew); + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final Object currentVal = vals[idx]; + + if (currentVal.equals(val)) { + return this; + } else { + // add new mapping + final Object[] src = this.vals; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final AbstractMapNode thisNew = + new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(this.hash, this.keys, + dst); + + details.updated(EitherIntOrObject.ofObject(currentVal)); + return thisNew; + } + } + } + + final Object[] keysNew = (Object[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final Object[] valsNew = (Object[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(keyHash, keysNew, valsNew); + } + + @Override + Map.Entry getKeyValueEntry(final int index) { + return entryOf(keys[index], vals[index]); + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final Object key, + final Object val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final Object currentVal = vals[idx]; + + if (cmp.compare(currentVal, val) == 0) { + return this; + } else { + // add new mapping + final Object[] src = this.vals; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final AbstractMapNode thisNew = + new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(this.hash, this.keys, + dst); + + details.updated(EitherIntOrObject.ofObject(currentVal)); + return thisNew; + } + } + } + + final Object[] keysNew = (Object[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final Object[] valsNew = (Object[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(keyHash, keysNew, valsNew); + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final Object key, + final Object val, final int keyHash, final int shift, final MapResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final Object currentVal = vals[idx]; + + if (currentVal.equals(val)) { + return this; + } else { + // add new mapping + final Object[] src = this.vals; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final AbstractMapNode thisNew = + new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(this.hash, this.keys, + dst); + + details.updated(EitherIntOrObject.ofObject(currentVal)); + return thisNew; + } + } + } + + final Object[] keysNew = (Object[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final Object[] valsNew = (Object[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(keyHash, keysNew, valsNew); + } + + @Override + Optional findByKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final Object _key = keys[i]; + if (cmp.compare(_key, key) == 0) { + final Object val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + int getKey(final int index) { + throw new IllegalStateException("Converted to `rarePayload`."); + } + + @Override + public String toString() { + throw new UnsupportedOperationException("Not yet implemented."); + } + + @Override + Object getRareKey(final int index) { + return keys[index]; + } + + @Override + boolean containsKeyEquivalent(final Object key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (Object k : keys) { + if (cmp.compare(k, key) == 0) { + return true; + } + } + } + return false; + } + + @Override + boolean containsKey(final int key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (Object k : keys) { + if (k.equals(key)) { + return true; + } + } + } + return false; + } + + @Override + int untypedSlotArity() { + throw new UnsupportedOperationException(); + } + + @Override + Optional findByKey(final Object key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final Object _key = keys[i]; + if (cmp.compare(_key, key) == 0) { + final Object val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + Optional findByKey(final int key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final Object _key = keys[i]; + if (_key.equals(key)) { + final Object val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + int payloadArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final Object currentVal = vals[idx]; + details.updated(EitherIntOrObject.ofObject(currentVal)); + + if (this.arity() == 1) { + return EMPTY_NODE; + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final Object theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final Object theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return EMPTY_NODE.updated(mutator, theOtherKey, theOtherVal, keyHash, 0, details, cmp); + } else { + final Object[] keysNew = (Object[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final Object[] valsNew = (Object[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(keyHash, keysNew, + valsNew); + } + } + } + return this; + } + + @Override + Optional findByKey(final Object key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final Object _key = keys[i]; + if (_key.equals(key)) { + final Object val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final Object key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final Object currentVal = vals[idx]; + details.updated(EitherIntOrObject.ofObject(currentVal)); + + if (this.arity() == 1) { + return EMPTY_NODE; + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final Object theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final Object theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return EMPTY_NODE.updated(mutator, theOtherKey, theOtherVal, keyHash, 0, details, cmp); + } else { + final Object[] keysNew = (Object[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final Object[] valsNew = (Object[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(keyHash, keysNew, + valsNew); + } + } + } + return this; + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final Object currentVal = vals[idx]; + details.updated(EitherIntOrObject.ofObject(currentVal)); + + if (this.arity() == 1) { + return EMPTY_NODE; + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final Object theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final Object theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return EMPTY_NODE.updated(mutator, theOtherKey, theOtherVal, keyHash, 0, details); + } else { + final Object[] keysNew = (Object[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final Object[] valsNew = (Object[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(keyHash, keysNew, + valsNew); + } + } + } + return this; + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int nodeArity() { + return 0; + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final Object key, + final int keyHash, final int shift, final MapResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final Object currentVal = vals[idx]; + details.updated(EitherIntOrObject.ofObject(currentVal)); + + if (this.arity() == 1) { + return EMPTY_NODE; + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final Object theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final Object theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return EMPTY_NODE.updated(mutator, theOtherKey, theOtherVal, keyHash, 0, details); + } else { + final Object[] keysNew = (Object[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final Object[] valsNew = (Object[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge(keyHash, keysNew, + valsNew); + } + } + } + return this; + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge that = + (HashCollisionMapNode_5Bits_Heterogeneous_BleedingEdge) other; + + if (hash != that.hash) { + return false; + } + + if (arity() != that.arity()) { + return false; + } + + /* + * Linear scan for each key, because of arbitrary element order. + */ + outerLoop: + for (int i = 0; i < that.payloadArity(); i++) { + final Object otherKey = that.getKey(i); + final Object otherVal = that.getVal(i); + + for (int j = 0; j < keys.length; j++) { + final Object key = keys[j]; + final Object val = vals[j]; + + if (key.equals(otherKey) && val.equals(otherVal)) { + continue outerLoop; + } + } + return false; + } + + return true; + } + + @Override + boolean containsKeyEquivalent(final int key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (Object k : keys) { + if (cmp.compare(k, key) == 0) { + return true; + } + } + } + return false; + } + + @Override + boolean containsKey(final Object key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (Object k : keys) { + if (k.equals(key)) { + return true; + } + } + } + return false; + } + + @Override + byte sizePredicate() { + return sizeMoreThanOne(); + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + Object getRareVal(final int index) { + return vals[index]; + } + + @Override + int rarePayloadArity() { + return keys.length; + } + + @Override + AbstractMapNode getNode(final int index) { + throw new IllegalStateException("Is leaf node."); + } + + @Override + int getVal(final int index) { + throw new IllegalStateException("Converted to `rarePayload`."); + } + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractMapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractMapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractMapNode[] nodes = new AbstractMapNode[MAX_DEPTH]; + + AbstractMapIterator(AbstractMapNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractMapNode nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class MapKeyIterator extends AbstractMapIterator implements Iterator { + + MapKeyIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public Object next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + protected static class MapValueIterator extends AbstractMapIterator implements Iterator { + + MapValueIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public Object next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getVal(currentValueCursor++); + } + } + + } + + protected static class MapEntryIterator extends AbstractMapIterator + implements Iterator> { + + MapEntryIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKeyValueEntry(currentValueCursor++); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieMap_5Bits_Heterogeneous_BleedingEdgeNodeIterator + implements Iterator { + + final Deque> nodeIteratorStack; + + TrieMap_5Bits_Heterogeneous_BleedingEdgeNodeIterator(AbstractMapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractMapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieMap_5Bits_Heterogeneous_BleedingEdge + implements io.usethesource.capsule.Map.Transient { + + final private AtomicReference mutator; + private AbstractMapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieMap_5Bits_Heterogeneous_BleedingEdge( + TrieMap_5Bits_Heterogeneous_BleedingEdge trieMap_5Bits_Heterogeneous_BleedingEdge) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieMap_5Bits_Heterogeneous_BleedingEdge.rootNode; + this.hashCode = trieMap_5Bits_Heterogeneous_BleedingEdge.hashCode; + this.cachedSize = trieMap_5Bits_Heterogeneous_BleedingEdge.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final Object key = entry.getKey(); + final Object val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public Object put(final Object key, final Object val) { + throw new UnsupportedOperationException(); + } + + @Override + public void putAll(final Map m) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public Object remove(final Object key) { + throw new UnsupportedOperationException(); + } + + public boolean containsKey(final int key) { + return rootNode.containsKey(key, transformHashCode(key), 0); + } + + public boolean containsKeyEquivalent(final int key, final Comparator cmp) { + return rootNode.containsKeyEquivalent(key, transformHashCode(key), 0, cmp); + } + + @Override + public boolean containsKey(final Object o) { + try { + final Object key = (Object) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + final Object key = (Object) o; + return rootNode.containsKeyEquivalent(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + @Override + public Object get(final Object o) { + try { + final int key = (int) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public Object getEquivalent(final Object o, final Comparator cmp) { + try { + final int key = (int) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public Object __put(final int key, final int val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int replacedValue = details.getReplacedValue().getInt(); + + final int valHashOld = replacedValue; + final int valHashNew = val; + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return replacedValue; + } else { + final int valHashNew = (int) val; + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + public Object __putEquivalent(final int key, final int val, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int replacedValue = details.getReplacedValue().getInt(); + + final int valHashOld = replacedValue; + final int valHashNew = val; + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return replacedValue; + } else { + final int valHashNew = (int) val; + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + @Override + public Object __put(final Object key, final Object val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final Object replacedValue = details.getReplacedValue().getObject(); + + final int valHashOld = replacedValue.hashCode(); + final int valHashNew = val.hashCode(); + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return replacedValue; + } else { + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + @Override + public Object __putEquivalent(final Object key, final Object val, + final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final Object replacedValue = details.getReplacedValue().getObject(); + + final int valHashOld = replacedValue.hashCode(); + final int valHashNew = val.hashCode(); + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return replacedValue; + } else { + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + @Override + public boolean __putAll(final Map map) { + boolean modified = false; + + for (Map.Entry entry : map.entrySet()) { + final boolean isPresent = this.containsKey(entry.getKey()); + final Object replaced = this.__put(entry.getKey(), entry.getValue()); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + @Override + public boolean __putAllEquivalent(final Map map, + final Comparator cmp) { + boolean modified = false; + + for (Map.Entry entry : map.entrySet()) { + final boolean isPresent = this.containsKeyEquivalent(entry.getKey(), cmp); + final Object replaced = this.__putEquivalent(entry.getKey(), entry.getValue(), cmp); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + public Object __remove(final int key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getInt(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + public Object __removeEquivalent(final int key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getInt(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + @Override + public Object __remove(final Object key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getObject().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + @Override + public Object __removeEquivalent(final Object key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getObject().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new TransientMapKeyIterator(this); + } + + @Override + public Iterator valueIterator() { + return new TransientMapValueIterator(this); + } + + @Override + public Iterator> entryIterator() { + return new TransientMapEntryIterator(this); + } + + public static class TransientMapKeyIterator extends MapKeyIterator { + + final TransientTrieMap_5Bits_Heterogeneous_BleedingEdge collection; + Object lastKey; + + public TransientMapKeyIterator( + final TransientTrieMap_5Bits_Heterogeneous_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public Object next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(lastKey); + } + } + + public static class TransientMapValueIterator extends MapValueIterator { + + final TransientTrieMap_5Bits_Heterogeneous_BleedingEdge collection; + + public TransientMapValueIterator( + final TransientTrieMap_5Bits_Heterogeneous_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public Object next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientMapEntryIterator extends MapEntryIterator { + + final TransientTrieMap_5Bits_Heterogeneous_BleedingEdge collection; + + public TransientMapEntryIterator( + final TransientTrieMap_5Bits_Heterogeneous_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public Map.Entry next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits_Heterogeneous_BleedingEdge.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieMap_5Bits_Heterogeneous_BleedingEdge) { + TransientTrieMap_5Bits_Heterogeneous_BleedingEdge that = + (TransientTrieMap_5Bits_Heterogeneous_BleedingEdge) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final Object key = (Object) entry.getKey(); + final Optional result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + final Object val = (Object) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public io.usethesource.capsule.Map.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieMap_5Bits_Heterogeneous_BleedingEdge(rootNode, hashCode, cachedSize); + } + } + + private abstract static class DataLayoutHelper extends CompactMapNode { + + private static final long[] arrayOffsets = + arrayOffsets(DataLayoutHelper.class, new String[]{"slot0", "slot1"}); + + public final Object slot0 = null; + + public final Object slot1 = null; + + private DataLayoutHelper() { + super(null, (int) 0, (int) 0); + } + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/heterogeneous/TrieMap_5Bits_Heterogeneous_BleedingEdge_IntIntSpecializations.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/heterogeneous/TrieMap_5Bits_Heterogeneous_BleedingEdge_IntIntSpecializations.java new file mode 100644 index 0000000..96fb048 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/heterogeneous/TrieMap_5Bits_Heterogeneous_BleedingEdge_IntIntSpecializations.java @@ -0,0 +1,123458 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.heterogeneous; + +import java.util.concurrent.atomic.AtomicReference; + +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_5Bits_Heterogeneous_BleedingEdge.CompactMapNode; + +@SuppressWarnings({"unused", "rawtypes", "restriction"}) +public class TrieMap_5Bits_Heterogeneous_BleedingEdge_IntIntSpecializations { + + protected static class Map12To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + + protected Map12To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + } + } + + protected static class Map29To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 58 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final Object slot0; + private final Object slot1; + + protected Map29To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map6To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map6To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map2To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map2To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map27To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 54 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map27To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map2To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map2To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map1To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map1To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map1To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map1To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map5To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map5To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map6To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map6To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map20To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map20To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map4To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map4To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map3To46Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 46; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected Map3To46Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class Map1To61Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 61; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 60 * addressSize; + + static final long nodeBase = rareBase + 61 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + + protected Map1To61Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57, final Object slot58, final Object slot59, final Object slot60) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + } + } + + protected static class Map23To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map23To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map18To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + + protected Map18To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + } + } + + protected static class Map17To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map17To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map4To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map4To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map26To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 52 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map26To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map7To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map7To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map15To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map15To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map5To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map5To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map12To39Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 39; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected Map12To39Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class Map11To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map11To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map31To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 31; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 62 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final int key30; + private final int val30; + private final int key31; + private final int val31; + + protected Map31To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final int key30, final int val30, final int key31, final int val31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + } + } + + protected static class Map7To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map7To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map16To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map16To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map3To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map3To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map0To45Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 45; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected Map0To45Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class Map13To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map13To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map21To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map21To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map9To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map9To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map6To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map6To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map1To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map1To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map15To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map15To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map10To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + + protected Map10To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map5To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map5To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map3To44Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 44; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected Map3To44Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class Map3To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map3To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map26To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 52 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map26To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map7To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map7To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map11To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map11To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map8To47Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 47; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected Map8To47Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class Map8To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map8To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map1To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map1To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map0To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final Object slot0; + private final Object slot1; + + protected Map0To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map5To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map5To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map2To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map2To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map16To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map16To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map28To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 56 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final Object slot0; + + protected Map28To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + } + } + + protected static class Map9To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map9To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map26To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 52 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map26To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map4To50Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 50; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected Map4To50Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class Map2To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map2To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map19To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map19To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map13To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map13To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map0To51Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 51; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected Map0To51Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class Map7To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map7To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map8To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + + protected Map8To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + } + } + + protected static class Map17To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map17To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map14To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + + protected Map14To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + } + } + + protected static class Map9To41Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 41; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected Map9To41Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class Map12To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map12To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map2To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map2To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map11To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map11To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map8To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map8To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map3To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map3To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map27To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 54 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map27To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map10To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map10To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map19To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map19To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map1To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map1To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map12To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map12To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map24To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + + protected Map24To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + } + } + + protected static class Map6To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map6To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map0To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map0To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map7To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map7To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map13To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map13To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map22To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + + protected Map22To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + } + } + + protected static class Map13To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map13To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map0To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map0To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class Map0To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map0To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map9To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map9To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map18To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map18To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map4To39Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 39; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected Map4To39Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class Map16To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map16To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map3To57Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 57; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected Map3To57Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54, final Object slot55, final Object slot56) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class Map2To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map2To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map6To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map6To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map5To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map5To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map22To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map22To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map10To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map10To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class Map10To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map10To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map4To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + + protected Map4To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + } + } + + protected static class Map17To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map17To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map5To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map5To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map9To40Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 40; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected Map9To40Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class Map8To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map8To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map17To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map17To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map9To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map9To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map13To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map13To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map20To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map20To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map2To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map2To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map11To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map11To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map26To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 52 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map26To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map23To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map23To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map6To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map6To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map13To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map13To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map17To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map17To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map16To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map16To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map8To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map8To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map1To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map1To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map2To60Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 60; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 59 * addressSize; + + static final long nodeBase = rareBase + 60 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + + protected Map2To60Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58, + final Object slot59) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + } + } + + protected static class Map21To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map21To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map11To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map11To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map6To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map6To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map10To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map10To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map30To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 60 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final int key30; + private final int val30; + private final Object slot0; + private final Object slot1; + + protected Map30To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final int key30, final int val30, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map7To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map7To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map3To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map3To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map3To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map3To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map15To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map15To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map4To48Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 48; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected Map4To48Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class Map28To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 56 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map28To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map0To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map0To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map15To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + + protected Map15To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + } + } + + protected static class Map14To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map14To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map5To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map5To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map17To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map17To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map14To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map14To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map25To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map25To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map1To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map1To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map4To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map4To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map22To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map22To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map2To50Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 50; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected Map2To50Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class Map9To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + + protected Map9To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map6To48Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 48; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected Map6To48Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class Map1To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map1To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map20To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map20To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map10To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map10To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map24To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map24To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map7To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map7To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map26To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 52 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map26To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map19To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map19To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map8To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map8To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map11To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map11To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map14To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map14To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map13To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map13To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map3To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map3To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map0To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map0To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map23To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map23To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map12To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map12To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map18To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map18To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map5To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map5To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map15To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map15To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map4To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map4To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map14To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map14To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map13To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map13To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map11To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map11To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map1To57Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 57; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected Map1To57Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class Map12To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map12To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map6To39Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 39; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected Map6To39Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class Map4To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map4To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map21To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + + protected Map21To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + } + } + + protected static class Map0To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map0To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map9To45Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 45; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected Map9To45Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class Map12To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map12To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map10To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map10To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map3To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map3To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map7To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map7To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map20To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map20To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map19To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map19To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map2To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map2To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map15To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map15To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map0To52Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 52; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected Map0To52Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class Map7To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map7To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map8To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map8To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map6To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + + protected Map6To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + } + } + + protected static class Map5To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map5To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map2To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map2To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map16To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + + protected Map16To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map4To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map4To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map1To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map1To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map21To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map21To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map18To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map18To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map4To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map4To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map11To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map11To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map13To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map13To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map16To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map16To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map26To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 52 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final Object slot0; + + protected Map26To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + } + } + + protected static class Map2To48Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 48; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected Map2To48Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class Map12To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map12To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map13To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map13To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map7To46Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 46; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected Map7To46Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class Map10To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map10To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map1To44Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 44; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected Map1To44Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class Map8To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map8To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map5To44Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 44; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected Map5To44Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class Map8To43Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 43; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected Map8To43Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class Map0To58Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 58; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected Map0To58Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54, final Object slot55, final Object slot56, final Object slot57) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class Map18To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map18To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map25To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map25To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map0To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map0To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map12To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map12To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map17To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map17To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map3To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map3To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map21To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map21To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map6To50Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 50; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected Map6To50Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class Map0To40Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 40; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected Map0To40Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class Map0To55Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 55; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected Map0To55Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class Map3To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map3To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map17To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map17To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map28To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 56 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map28To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map16To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map16To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map7To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map7To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map9To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map9To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map14To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map14To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map11To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map11To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map15To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map15To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map1To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map1To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map14To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map14To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map28To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 56 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map28To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map5To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map5To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map10To40Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 40; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected Map10To40Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class Map4To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map4To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map11To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map11To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map1To46Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 46; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected Map1To46Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class Map0To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map0To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map5To46Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 46; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected Map5To46Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class Map12To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map12To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map23To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + + protected Map23To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map17To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map17To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map22To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map22To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map2To39Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 39; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected Map2To39Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class Map3To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map3To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map18To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map18To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map8To42Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 42; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected Map8To42Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class Map12To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map12To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map3To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map3To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map1To59Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 59; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 58 * addressSize; + + static final long nodeBase = rareBase + 59 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + + protected Map1To59Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57, final Object slot58) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + } + } + + protected static class Map7To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map7To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map11To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map11To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map7To44Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 44; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected Map7To44Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class Map6To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map6To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map5To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map5To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map14To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map14To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map9To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map9To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class Map20To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + + protected Map20To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map9To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map9To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map8To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map8To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map2To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + + protected Map2To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + } + } + + protected static class Map0To41Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 41; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected Map0To41Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class Map1To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map1To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map18To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map18To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map25To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map25To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map19To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map19To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map9To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map9To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map16To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map16To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map4To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map4To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map13To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map13To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map24To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map24To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map10To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map10To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map19To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + + protected Map19To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + } + } + + protected static class Map14To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map14To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map10To41Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 41; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected Map10To41Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class Map6To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map6To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map15To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map15To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map28To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 56 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map28To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map14To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map14To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map3To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map3To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map11To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map11To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map16To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map16To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map9To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map9To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map21To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map21To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map15To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map15To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map4To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + + protected Map4To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map8To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map8To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map4To51Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 51; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected Map4To51Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class Map5To54Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 54; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected Map5To54Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class Map12To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map12To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map6To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map6To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map2To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map2To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map1To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map1To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map11To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map11To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map13To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map13To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map16To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map16To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map20To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map20To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map5To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map5To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map3To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map3To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map1To54Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 54; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected Map1To54Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class Map29To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 58 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map29To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map6To40Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 40; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected Map6To40Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class Map17To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map17To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map7To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map7To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map8To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map8To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map14To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map14To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map18To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map18To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map9To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map9To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map0To50Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 50; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected Map0To50Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class Map23To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map23To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map20To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map20To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map10To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map10To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map9To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map9To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map0To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map0To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map9To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map9To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map3To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map3To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map8To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map8To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map0To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map0To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map2To52Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 52; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected Map2To52Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class Map6To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map6To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map15To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map15To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map21To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map21To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map30To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 60 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final int key30; + private final int val30; + private final Object slot0; + + protected Map30To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final int key30, final int val30, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + } + } + + protected static class Map12To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map12To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map12To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map12To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class Map4To45Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 45; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected Map4To45Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class Map14To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map14To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map18To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map18To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map16To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map16To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map1To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map1To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map21To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map21To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map5To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map5To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map11To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map11To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map32To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 32; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 64 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final int key30; + private final int val30; + private final int key31; + private final int val31; + private final int key32; + private final int val32; + + protected Map32To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final int key30, final int val30, final int key31, final int val31, final int key32, + final int val32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + this.key32 = key32; + this.val32 = val32; + } + } + + protected static class Map6To41Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 41; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected Map6To41Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class Map10To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map10To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map13To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map13To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map19To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map19To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map23To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map23To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map12To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map12To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map17To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map17To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map18To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map18To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map2To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map2To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map7To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map7To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map17To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map17To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map23To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map23To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map19To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map19To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map1To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map1To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map1To43Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 43; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected Map1To43Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class Map23To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map23To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map18To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + + protected Map18To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map11To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map11To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map20To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map20To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map3To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + + protected Map3To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + } + } + + protected static class Map11To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + + protected Map11To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + } + } + + protected static class Map2To40Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 40; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected Map2To40Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class Map2To55Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 55; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected Map2To55Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class Map4To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map4To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map7To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map7To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map0To48Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 48; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected Map0To48Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class Map25To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + + protected Map25To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + } + } + + protected static class Map8To44Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 44; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected Map8To44Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class Map15To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map15To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map5To43Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 43; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected Map5To43Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class Map2To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map2To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map17To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + + protected Map17To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + } + } + + protected static class Map2To58Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 58; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected Map2To58Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class Map8To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map8To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map6To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map6To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map7To42Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 42; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected Map7To42Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class Map5To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map5To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map13To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map13To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map3To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map3To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map15To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map15To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map12To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + + protected Map12To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map9To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map9To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map3To47Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 47; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected Map3To47Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class Map29To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 58 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final Object slot0; + + protected Map29To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + } + } + + protected static class Map16To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map16To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map20To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map20To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map6To52Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 52; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected Map6To52Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class Map3To56Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 56; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected Map3To56Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54, final Object slot55) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class Map9To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map9To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map4To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map4To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map5To53Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 53; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected Map5To53Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class Map14To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + + protected Map14To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map15To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map15To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map22To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map22To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map28To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 56 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final Object slot0; + private final Object slot1; + + protected Map28To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map1To42Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 42; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected Map1To42Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class Map7To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map7To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map0To39Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 39; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected Map0To39Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class Map5To42Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 42; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected Map5To42Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class Map30To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 60 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final int key30; + private final int val30; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map30To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final int key30, final int val30, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map8To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map8To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map5To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map5To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map0To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final Object slot0; + + protected Map0To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + } + } + + protected static class Map2To41Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 41; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected Map2To41Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class Map19To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map19To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map10To39Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 39; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected Map10To39Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class Map23To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map23To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map2To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map2To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map13To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map13To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map6To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map6To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map1To53Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 53; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected Map1To53Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class Map16To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map16To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map19To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map19To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map7To43Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 43; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected Map7To43Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class Map9To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map9To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map10To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + + protected Map10To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + } + } + + protected static class Map3To49Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 49; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected Map3To49Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class Map8To46Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 46; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected Map8To46Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class Map21To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map21To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map1To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map1To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map20To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map20To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map4To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map4To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map4To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map4To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class Map0To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map0To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map6To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map6To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map4To52Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 52; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected Map4To52Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class Map4To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map4To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map3To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map3To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map0To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map0To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map9To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map9To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map5To49Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 49; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected Map5To49Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class Map22To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map22To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map1To56Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 56; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected Map1To56Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class Map13To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map13To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map2To45Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 45; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected Map2To45Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class Map14To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map14To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map10To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map10To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map7To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map7To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map21To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map21To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map8To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map8To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map8To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map8To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map3To42Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 42; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected Map3To42Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class Map11To42Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 42; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected Map11To42Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class Map15To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map15To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map19To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map19To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map1To49Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 49; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected Map1To49Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class Map11To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map11To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map12To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map12To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map10To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map10To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map7To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + + protected Map7To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + } + } + + protected static class Map6To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map6To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map6To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map6To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class Map17To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map17To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map9To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map9To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map3To53Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 53; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected Map3To53Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class Map24To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map24To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map26To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 52 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final Object slot0; + private final Object slot1; + + protected Map26To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final Object slot0, + final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map7To47Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 47; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected Map7To47Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class Map5To47Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 47; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected Map5To47Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class Map5To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map5To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map1To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + + protected Map1To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + } + } + + protected static class Map17To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map17To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map29To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 58 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map29To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map14To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map14To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map2To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + + protected Map2To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map19To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map19To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map11To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map11To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map1To47Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 47; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected Map1To47Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class Map6To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map6To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map1To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map1To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map0To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map0To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map12To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map12To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map23To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + + protected Map23To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + } + } + + protected static class Map8To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map8To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map18To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map18To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map0To62Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 62; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 61 * addressSize; + + static final long nodeBase = rareBase + 62 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + + protected Map0To62Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54, final Object slot55, final Object slot56, final Object slot57, + final Object slot58, final Object slot59, final Object slot60, final Object slot61) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + } + } + + protected static class Map21To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map21To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map2To51Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 51; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected Map2To51Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class Map10To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map10To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map12To40Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 40; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected Map12To40Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class Map4To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map4To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map16To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map16To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map5To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + + protected Map5To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + } + } + + protected static class Map0To64Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 64; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 63 * addressSize; + + static final long nodeBase = rareBase + 64 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + private final Object slot62; + private final Object slot63; + + protected Map0To64Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54, final Object slot55, final Object slot56, final Object slot57, + final Object slot58, final Object slot59, final Object slot60, final Object slot61, + final Object slot62, final Object slot63) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + this.slot62 = slot62; + this.slot63 = slot63; + } + } + + protected static class Map15To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map15To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map0To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map0To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map8To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map8To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map10To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map10To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map7To49Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 49; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected Map7To49Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class Map13To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map13To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map20To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + + protected Map20To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + } + } + + protected static class Map3To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map3To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map13To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map13To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map3To43Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 43; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected Map3To43Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class Map8To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map8To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map6To45Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 45; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected Map6To45Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class Map15To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map15To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map27To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 54 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + + protected Map27To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + } + } + + protected static class Map7To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map7To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map7To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map7To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map14To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map14To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map4To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map4To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map2To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map2To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map18To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map18To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map22To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map22To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map3To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map3To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map10To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map10To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map9To39Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 39; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected Map9To39Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class Map11To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map11To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map5To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map5To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map0To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map0To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map15To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map15To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map22To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map22To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map2To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map2To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class Map2To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map2To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map17To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map17To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map9To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + + protected Map9To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + } + } + + protected static class Map10To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map10To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map0To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map0To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map19To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map19To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map19To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map19To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map12To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map12To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map4To41Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 41; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected Map4To41Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class Map1To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map1To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map24To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map24To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map3To54Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 54; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected Map3To54Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class Map17To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map17To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map25To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map25To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map13To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + + protected Map13To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + } + } + + protected static class Map22To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map22To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map16To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + + protected Map16To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + } + } + + protected static class Map6To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + + protected Map6To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map24To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map24To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map19To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map19To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map18To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map18To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map0To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map0To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map20To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map20To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map4To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map4To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map15To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map15To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map7To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map7To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map23To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map23To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map10To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map10To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map0To60Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 60; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 59 * addressSize; + + static final long nodeBase = rareBase + 60 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + + protected Map0To60Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54, final Object slot55, final Object slot56, final Object slot57, + final Object slot58, final Object slot59) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + } + } + + protected static class Map14To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map14To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map13To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map13To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map5To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map5To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map3To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map3To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map2To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map2To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map1To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map1To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map8To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map8To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map11To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map11To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map15To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map15To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map6To51Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 51; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected Map6To51Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class Map1To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map1To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map4To40Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 40; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected Map4To40Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class Map4To55Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 55; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected Map4To55Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class Map12To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map12To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map26To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 52 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map26To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map5To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map5To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map30To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 60 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final int key30; + private final int val30; + + protected Map30To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final int key30, final int val30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + } + } + + protected static class Map0To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map0To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map7To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map7To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map13To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map13To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map12To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map12To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map1To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map1To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map6To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map6To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map4To44Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 44; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected Map4To44Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class Map7To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map7To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map27To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 54 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map27To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map3To50Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 50; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected Map3To50Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class Map1To60Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 60; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 59 * addressSize; + + static final long nodeBase = rareBase + 60 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + + protected Map1To60Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57, final Object slot58, final Object slot59) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + } + } + + protected static class Map8To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map8To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map6To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map6To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map16To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map16To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map0To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map0To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map18To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map18To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map5To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map5To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map19To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map19To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map15To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + + protected Map15To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map12To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map12To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map18To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map18To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map9To43Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 43; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected Map9To43Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class Map14To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map14To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map4To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map4To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map10To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map10To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map27To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 54 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map27To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map9To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map9To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map10To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map10To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map2To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map2To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map13To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map13To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map4To46Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 46; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected Map4To46Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class Map3To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map3To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map11To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map11To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map21To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map21To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map1To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map1To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map12To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map12To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map9To42Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 42; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected Map9To42Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class Map3To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map3To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map23To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map23To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map27To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 54 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map27To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map10To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map10To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map6To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map6To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map9To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map9To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map4To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map4To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map8To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map8To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class Map8To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map8To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map18To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map18To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map14To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map14To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map5To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map5To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map20To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map20To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map0To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map0To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map2To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map2To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map25To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map25To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map14To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map14To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map11To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map11To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map7To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map7To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map17To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map17To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map22To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + + protected Map22To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map13To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map13To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map16To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map16To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map13To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map13To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map1To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map1To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map6To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map6To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map26To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 52 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map26To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map8To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map8To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map24To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + + protected Map24To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map5To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map5To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map10To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map10To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map5To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map5To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map14To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map14To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map27To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 54 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map27To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map6To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map6To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map26To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 52 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map26To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map5To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map5To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map0To47Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 47; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected Map0To47Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class Map4To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map4To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map2To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map2To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map0To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + protected Map0To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap) { + super(mutator, nodeMap, dataMap); + + } + } + + protected static class Map3To48Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 48; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected Map3To48Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class Map13To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map13To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map1To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map1To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map7To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map7To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map10To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + + protected Map10To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + } + } + + protected static class Map7To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map7To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map23To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map23To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map12To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map12To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map2To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map2To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map18To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map18To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map4To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map4To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map0To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map0To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map1To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map1To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map16To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map16To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map20To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map20To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map1To62Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 62; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 61 * addressSize; + + static final long nodeBase = rareBase + 62 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + + protected Map1To62Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57, final Object slot58, final Object slot59, final Object slot60, + final Object slot61) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + } + } + + protected static class Map8To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + + protected Map8To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map24To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map24To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map15To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map15To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map22To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map22To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map9To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map9To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map21To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map21To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map11To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + + protected Map11To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + } + } + + protected static class Map15To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map15To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map29To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 58 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + + protected Map29To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + } + } + + protected static class Map7To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map7To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map2To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map2To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map2To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map2To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map5To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map5To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map3To39Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 39; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected Map3To39Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class Map11To39Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 39; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected Map11To39Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class Map0To49Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 49; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected Map0To49Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class Map13To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map13To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map3To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + + protected Map3To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + } + } + + protected static class Map19To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map19To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map0To56Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 56; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected Map0To56Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54, final Object slot55) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class Map1To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map1To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map17To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + + protected Map17To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + } + } + + protected static class Map14To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map14To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map31To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 31; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 62 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final int key30; + private final int val30; + private final int key31; + private final int val31; + private final Object slot0; + private final Object slot1; + + protected Map31To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final int key30, final int val30, final int key31, final int val31, final Object slot0, + final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map13To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map13To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map4To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map4To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map25To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + + protected Map25To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + } + } + + protected static class Map9To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map9To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map8To45Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 45; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected Map8To45Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class Map15To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map15To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map22To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map22To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map1To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map1To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map7To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map7To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map18To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map18To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map26To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 52 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map26To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map12To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map12To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map16To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map16To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map6To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map6To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map5To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map5To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map11To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map11To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map1To39Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 39; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected Map1To39Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class Map0To42Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 42; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected Map0To42Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class Map13To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map13To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map10To42Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 42; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected Map10To42Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class Map2To46Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 46; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected Map2To46Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class Map23To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map23To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map13To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map13To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map12To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map12To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map3To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map3To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map9To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map9To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map20To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + + protected Map20To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + } + } + + protected static class Map5To39Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 39; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected Map5To39Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class Map18To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map18To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map12To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map12To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map8To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map8To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map28To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 56 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map28To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map3To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map3To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map11To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map11To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map14To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map14To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map7To48Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 48; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected Map7To48Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class Map0To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map0To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map16To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map16To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map8To41Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 41; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected Map8To41Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class Map20To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map20To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map5To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + + protected Map5To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + } + } + + protected static class Map6To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map6To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map21To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map21To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map2To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map2To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map1To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + + protected Map1To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + } + } + + protected static class Map17To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map17To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map15To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map15To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map19To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + + protected Map19To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map25To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map25To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map17To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map17To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map4To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map4To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map0To53Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 53; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected Map0To53Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class Map10To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map10To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map2To59Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 59; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 58 * addressSize; + + static final long nodeBase = rareBase + 59 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + + protected Map2To59Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + } + } + + protected static class Map25To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map25To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map14To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map14To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map23To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + + protected Map23To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + } + } + + protected static class Map11To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map11To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map3To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map3To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map7To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + + protected Map7To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + } + } + + protected static class Map4To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map4To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map8To40Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 40; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected Map8To40Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class Map0To43Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 43; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected Map0To43Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class Map24To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map24To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map7To39Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 39; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected Map7To39Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class Map14To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map14To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map27To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 54 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map27To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map12To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map12To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map2To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map2To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map16To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map16To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map2To44Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 44; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected Map2To44Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class Map18To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map18To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map8To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map8To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map6To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map6To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map9To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map9To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map10To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map10To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map10To43Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 43; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected Map10To43Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class Map9To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map9To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map1To48Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 48; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected Map1To48Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class Map21To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map21To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map11To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map11To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map6To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map6To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map17To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map17To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map22To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map22To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map5To48Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 48; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected Map5To48Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class Map12To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map12To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map25To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map25To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map18To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map18To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map15To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map15To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map3To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map3To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map14To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map14To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map0To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map0To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map1To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map1To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map6To46Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 46; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected Map6To46Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class Map12To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map12To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map14To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map14To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map8To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map8To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map1To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map1To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map7To50Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 50; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected Map7To50Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class Map21To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + + protected Map21To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map4To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map4To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map4To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map4To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map11To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map11To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map5To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map5To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map6To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map6To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map2To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map2To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map22To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map22To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map10To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map10To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map25To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map25To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map3To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map3To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map17To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map17To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map11To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map11To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map24To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map24To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map28To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 56 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map28To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map15To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map15To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map16To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + + protected Map16To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + } + } + + protected static class Map5To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map5To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map13To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + + protected Map13To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + } + } + + protected static class Map2To57Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 57; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected Map2To57Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class Map3To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map3To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map16To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map16To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map19To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map19To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map0To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map0To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map15To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map15To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map0To54Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 54; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected Map0To54Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class Map1To50Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 50; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected Map1To50Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class Map4To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map4To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map5To50Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 50; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected Map5To50Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class Map7To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map7To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map17To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map17To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map8To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map8To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map18To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map18To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map12To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map12To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map6To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map6To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map27To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 54 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final Object slot0; + + protected Map27To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + } + } + + protected static class Map2To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map2To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map4To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map4To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map3To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map3To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map10To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map10To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map2To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map2To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map0To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map0To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map6To44Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 44; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected Map6To44Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class Map9To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + + protected Map9To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + } + } + + protected static class Map20To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map20To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map11To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map11To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map7To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map7To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map19To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map19To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map9To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map9To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map14To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map14To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map6To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map6To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map7To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map7To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map2To42Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 42; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected Map2To42Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class Map8To39Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 39; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected Map8To39Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class Map23To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map23To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map5To41Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 41; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected Map5To41Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class Map5To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map5To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map20To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map20To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map1To41Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 41; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected Map1To41Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class Map0To46Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 46; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected Map0To46Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class Map7To40Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 40; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected Map7To40Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class Map28To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 56 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + + protected Map28To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + } + } + + protected static class Map19To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map19To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map23To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map23To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map2To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map2To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map8To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + + protected Map8To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + } + } + + protected static class Map15To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map15To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map14To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + + protected Map14To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + } + } + + protected static class Map20To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map20To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map10To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map10To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map13To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map13To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map9To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map9To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map14To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map14To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map0To59Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 59; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 58 * addressSize; + + static final long nodeBase = rareBase + 59 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + + protected Map0To59Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54, final Object slot55, final Object slot56, final Object slot57, + final Object slot58) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + } + } + + protected static class Map21To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map21To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map4To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map4To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map2To53Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 53; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected Map2To53Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class Map1To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map1To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map16To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map16To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map3To45Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 45; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected Map3To45Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class Map0To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map0To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map23To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map23To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map7To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map7To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map19To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map19To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map3To51Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 51; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected Map3To51Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class Map24To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map24To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map13To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map13To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map2To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map2To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map10To44Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 44; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected Map10To44Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class Map9To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map9To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map20To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map20To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map18To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + + protected Map18To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + } + } + + protected static class Map7To41Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 41; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected Map7To41Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class Map8To48Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 48; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected Map8To48Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class Map25To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + private final Object slot1; + + protected Map25To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map19To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map19To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map22To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map22To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map17To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + + protected Map17To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map31To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 31; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 62 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final int key30; + private final int val30; + private final int key31; + private final int val31; + private final Object slot0; + + protected Map31To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final int key30, final int val30, final int key31, final int val31, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + this.slot0 = slot0; + } + } + + protected static class Map0To44Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 44; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected Map0To44Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class Map16To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map16To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map6To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map6To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map0To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map0To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map5To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map5To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map2To43Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 43; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected Map2To43Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class Map11To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + + protected Map11To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map21To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map21To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map1To58Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 58; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected Map1To58Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class Map18To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map18To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map3To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + + protected Map3To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map12To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map12To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map1To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map1To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map4To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map4To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map5To40Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 40; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected Map5To40Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class Map10To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map10To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map4To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map4To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map12To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + + protected Map12To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + } + } + + protected static class Map1To55Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 55; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected Map1To55Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class Map1To40Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 40; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected Map1To40Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class Map1To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map1To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map5To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map5To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map0To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map0To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map5To52Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 52; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected Map5To52Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class Map21To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map21To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map20To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map20To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map12To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map12To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map0To57Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 57; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected Map0To57Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54, final Object slot55, final Object slot56) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class Map23To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 46 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map23To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map8To37Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 37; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected Map8To37Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class Map6To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map6To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map26To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 52 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map26To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map11To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map11To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map3To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map3To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map8To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map8To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map15To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + + protected Map15To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + } + } + + protected static class Map11To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map11To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class Map11To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map11To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map4To49Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 49; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected Map4To49Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class Map3To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map3To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class Map3To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map3To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map9To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map9To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map1To52Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 52; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected Map1To52Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class Map25To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map25To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map9To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map9To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map16To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map16To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map17To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map17To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map18To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map18To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map2To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map2To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map13To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map13To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map17To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map17To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map4To56Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 56; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected Map4To56Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class Map14To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map14To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map10To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map10To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map14To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map14To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map19To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map19To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map7To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map7To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map16To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map16To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map6To42Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 42; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected Map6To42Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class Map1To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map1To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map4To47Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 47; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected Map4To47Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class Map4To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map4To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map0To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map0To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map21To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map21To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map9To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map9To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map16To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map16To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map2To54Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 54; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected Map2To54Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class Map0To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map0To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map14To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map14To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map19To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map19To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map9To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map9To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map3To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map3To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map22To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + + protected Map22To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + } + } + + protected static class Map6To43Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 43; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected Map6To43Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class Map12To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map12To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map4To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + + protected Map4To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + } + } + + protected static class Map12To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map12To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map5To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map5To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map10To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map10To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map6To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map6To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map21To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map21To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map18To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map18To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map24To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + + protected Map24To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + } + } + + protected static class Map17To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map17To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map13To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map13To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map11To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map11To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map7To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map7To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map2To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map2To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map10To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map10To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map22To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map22To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map10To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map10To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map6To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + + protected Map6To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + } + } + + protected static class Map2To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map2To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map21To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + + protected Map21To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + } + } + + protected static class Map20To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map20To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map0To63Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 63; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 62 * addressSize; + + static final long nodeBase = rareBase + 63 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + private final Object slot62; + + protected Map0To63Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54, final Object slot55, final Object slot56, final Object slot57, + final Object slot58, final Object slot59, final Object slot60, final Object slot61, + final Object slot62) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + this.slot62 = slot62; + } + } + + protected static class Map18To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map18To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map11To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map11To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map12To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map12To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map8To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map8To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map24To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map24To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map17To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map17To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map4To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map4To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map19To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map19To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map15To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map15To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map9To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map9To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map4To43Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 43; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected Map4To43Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class Map14To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map14To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map9To44Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 44; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected Map9To44Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class Map5To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map5To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map13To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + + protected Map13To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map30To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 60 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final int key30; + private final int val30; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map30To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final int key30, final int val30, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map7To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map7To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map7To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map7To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class Map24To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map24To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map6To47Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 47; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected Map6To47Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class Map1To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map1To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map2To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map2To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map22To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map22To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map6To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map6To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map16To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map16To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map7To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map7To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map15To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map15To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map3To28Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 28; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected Map3To28Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class Map0To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map0To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map16To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map16To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map24To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map24To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map1To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map1To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map20To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map20To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map8To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map8To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map4To42Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 42; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected Map4To42Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class Map3To52Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 52; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected Map3To52Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class Map12To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map12To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map22To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map22To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map17To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map17To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map15To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map15To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map25To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map25To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map2To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map2To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map4To53Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 53; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected Map4To53Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class Map0To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map0To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map29To6Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 58 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map29To6Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map6To49Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 49; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected Map6To49Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class Map27To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 54 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final Object slot0; + private final Object slot1; + + protected Map27To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map8To35Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 35; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected Map8To35Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class Map5To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map5To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map14To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map14To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map15To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map15To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map3To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map3To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map10To32Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 32; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected Map10To32Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class Map5To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map5To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map5To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map5To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class Map7To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map7To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map9To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map9To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map4To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map4To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map9To46Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 46; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected Map9To46Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class Map11To14Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map11To14Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map1To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map1To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class Map1To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map1To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map9To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map9To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map16To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map16To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map3To58Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 58; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected Map3To58Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54, final Object slot55, final Object slot56, final Object slot57) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class Map0To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map0To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map4To12Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map4To12Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map11To40Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 40; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected Map11To40Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class Map21To3Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 42 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map21To3Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map10To17Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 17; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected Map10To17Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class Map24To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map24To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map25To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 50 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map25To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map5To51Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 51; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected Map5To51Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class Map12To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map12To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map2To18Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 18; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected Map2To18Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class Map27To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 54 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map27To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map13To20Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 20; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected Map13To20Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class Map5To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + + protected Map5To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map11To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map11To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map10To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map10To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map20To23Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 23; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected Map20To23Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class Map8To7Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map8To7Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map19To1Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 38 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final Object slot0; + + protected Map19To1Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + } + } + + protected static class Map1To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + + protected Map1To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map3To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map3To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map3To55Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 55; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected Map3To55Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class Map3To40Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 40; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected Map3To40Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class Map2To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + + protected Map2To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + } + } + + protected static class Map14To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map14To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map0To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map0To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map8To33Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 33; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected Map8To33Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class Map7To45Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 45; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected Map7To45Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class Map17To13Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 34 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map17To13Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map9To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map9To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map1To51Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 51; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected Map1To51Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class Map6To36Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 36; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected Map6To36Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class Map15To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map15To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map4To54Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 54; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected Map4To54Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class Map6To25Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 25; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected Map6To25Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class Map2To47Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 47; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected Map2To47Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class Map22To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map22To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map13To9Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map13To9Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map9To21Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 21; + + static final long rareBase = arrayBase + 18 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected Map9To21Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class Map16To19Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 19; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected Map16To19Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class Map8To5Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map8To5Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map0To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map0To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map1To45Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 45; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected Map1To45Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class Map11To41Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 41; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected Map11To41Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class Map5To45Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 45; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected Map5To45Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class Map18To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 36 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map18To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map3To41Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 41; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected Map3To41Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class Map10To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map10To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map10To11Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 20 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map10To11Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map26To0Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 52 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + + protected Map26To0Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + } + } + + protected static class Map6To22Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 22; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected Map6To22Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class Map24To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 48 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map24To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map7To2Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + + protected Map7To2Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map22To16Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 44 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map22To16Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map16To26Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 26; + + static final long rareBase = arrayBase + 32 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected Map16To26Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class Map15To10Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 30 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map15To10Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map4To30Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 30; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected Map4To30Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class Map29To4Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 58 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final int key21; + private final int val21; + private final int key22; + private final int val22; + private final int key23; + private final int val23; + private final int key24; + private final int val24; + private final int key25; + private final int val25; + private final int key26; + private final int val26; + private final int key27; + private final int val27; + private final int key28; + private final int val28; + private final int key29; + private final int val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map29To4Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final int key21, final int val21, final int key22, + final int val22, final int key23, final int val23, final int key24, final int val24, + final int key25, final int val25, final int key26, final int val26, final int key27, + final int val27, final int key28, final int val28, final int key29, final int val29, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map14To29Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 29; + + static final long rareBase = arrayBase + 28 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected Map14To29Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class Map0To34Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 34; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected Map0To34Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class Map8To8Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map8To8Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map3To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map3To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map11To31Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 31; + + static final long rareBase = arrayBase + 22 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected Map11To31Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class Map12To15Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 24 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map12To15Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map2To56Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 56; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected Map2To56Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class Map0To61Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 61; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 60 * addressSize; + + static final long nodeBase = rareBase + 61 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + + protected Map0To61Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37, + final Object slot38, final Object slot39, final Object slot40, final Object slot41, + final Object slot42, final Object slot43, final Object slot44, final Object slot45, + final Object slot46, final Object slot47, final Object slot48, final Object slot49, + final Object slot50, final Object slot51, final Object slot52, final Object slot53, + final Object slot54, final Object slot55, final Object slot56, final Object slot57, + final Object slot58, final Object slot59, final Object slot60) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + } + } + + protected static class Map2To49Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 49; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected Map2To49Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class Map20To24Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 24; + + static final long rareBase = arrayBase + 40 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + private final int key17; + private final int val17; + private final int key18; + private final int val18; + private final int key19; + private final int val19; + private final int key20; + private final int val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected Map20To24Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16, final int key17, + final int val17, final int key18, final int val18, final int key19, final int val19, + final int key20, final int val20, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class Map13To27Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 27; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected Map13To27Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class Map13To38Node_5Bits_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 38; + + static final long rareBase = arrayBase + 26 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected Map13To38Node_5Bits_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15, final Object slot16, final Object slot17, + final Object slot18, final Object slot19, final Object slot20, final Object slot21, + final Object slot22, final Object slot23, final Object slot24, final Object slot25, + final Object slot26, final Object slot27, final Object slot28, final Object slot29, + final Object slot30, final Object slot31, final Object slot32, final Object slot33, + final Object slot34, final Object slot35, final Object slot36, final Object slot37) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/heterogeneous/TrieMap_Heterogeneous_BleedingEdge.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/heterogeneous/TrieMap_Heterogeneous_BleedingEdge.java new file mode 100644 index 0000000..b2340e6 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/heterogeneous/TrieMap_Heterogeneous_BleedingEdge.java @@ -0,0 +1,4607 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.heterogeneous; + +import java.lang.reflect.Field; +import java.text.DecimalFormat; +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.atomic.AtomicReference; +import java.util.stream.Stream; + +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_Heterogeneous_BleedingEdge_Specializations.Map0To0Node_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_Heterogeneous_BleedingEdge_Specializations.Map0To1Node_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_Heterogeneous_BleedingEdge_Specializations.Map0To2Node_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_Heterogeneous_BleedingEdge_Specializations.Map0To4Node_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_Heterogeneous_BleedingEdge_Specializations.Map1To0Node_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_Heterogeneous_BleedingEdge_Specializations.Map1To2Node_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_Heterogeneous_BleedingEdge_Specializations.Map2To0Node_Heterogeneous_BleedingEdge; +import io.usethesource.capsule.util.RangecopyUtils.Companion; +import io.usethesource.capsule.util.RangecopyUtils.EitherIntOrObject; + +import static io.usethesource.capsule.util.BitmapUtils.isBitInBitmap; +import static io.usethesource.capsule.util.RangecopyUtils.getFromObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.rangecopyIntRegion; +import static io.usethesource.capsule.util.RangecopyUtils.rangecopyObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.setInIntRegion; +import static io.usethesource.capsule.util.RangecopyUtils.setInIntRegionVarArgs; +import static io.usethesource.capsule.util.RangecopyUtils.setInObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.setInObjectRegionVarArgs; +import static io.usethesource.capsule.util.RangecopyUtils.sizeOfObject; +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +public class TrieMap_Heterogeneous_BleedingEdge implements + io.usethesource.capsule.Map.Immutable { + + protected static final AbstractMapNode EMPTY_NODE = + new Map0To0Node_Heterogeneous_BleedingEdge(null, (byte) 0, (byte) 0); + + private static final TrieMap_Heterogeneous_BleedingEdge EMPTY_MAP = + new TrieMap_Heterogeneous_BleedingEdge(EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractMapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieMap_Heterogeneous_BleedingEdge(AbstractMapNode rootNode, int hashCode, int cachedSize) { + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final io.usethesource.capsule.Map.Immutable of() { + return TrieMap_Heterogeneous_BleedingEdge.EMPTY_MAP; + } + + public static final io.usethesource.capsule.Map.Immutable of( + Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + io.usethesource.capsule.Map.Immutable result = TrieMap_Heterogeneous_BleedingEdge.EMPTY_MAP; + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final int key = (int) keyValuePairs[i]; + final int val = (int) keyValuePairs[i + 1]; + + result = result.__put(key, val); + } + + return result; + } + + public static final io.usethesource.capsule.Map.Transient transientOf() { + return TrieMap_Heterogeneous_BleedingEdge.EMPTY_MAP.asTransient(); + } + + public static final io.usethesource.capsule.Map.Transient transientOf( + Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + final io.usethesource.capsule.Map.Transient result = + TrieMap_Heterogeneous_BleedingEdge.EMPTY_MAP.asTransient(); + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final int key = (int) keyValuePairs[i]; + final int val = (int) keyValuePairs[i + 1]; + + result.__put(key, val); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final Object key = entry.getKey(); + final Object val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + public boolean containsKey(final int key) { + return rootNode.containsKey(key, transformHashCode(key), 0); + } + + public boolean containsKeyEquivalent(final int key, final Comparator cmp) { + return rootNode.containsKeyEquivalent(key, transformHashCode(key), 0, cmp); + } + + @Override + public boolean containsKey(final Object o) { + try { + final Object key = (Object) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + final Object key = (Object) o; + return rootNode.containsKeyEquivalent(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + @Override + public Object get(final Object o) { + try { + final int key = (int) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public Object getEquivalent(final Object o, final Comparator cmp) { + try { + final int key = (int) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public io.usethesource.capsule.Map.Immutable __put(final int key, + final int val) { + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().getInt(); + final int valHashNew = val; + + return new TrieMap_Heterogeneous_BleedingEdge(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val; + + return new TrieMap_Heterogeneous_BleedingEdge(newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1); + } + + return this; + } + + public io.usethesource.capsule.Map.Immutable __putEquivalent(final int key, + final int val, + final Comparator cmp) { + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().getInt(); + final int valHashNew = val; + + return new TrieMap_Heterogeneous_BleedingEdge(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val; + + return new TrieMap_Heterogeneous_BleedingEdge(newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __put(final Object key, + final Object val) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().getObject().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieMap_Heterogeneous_BleedingEdge(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val.hashCode(); + + return new TrieMap_Heterogeneous_BleedingEdge(newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __putEquivalent(final Object key, + final Object val, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().getObject().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieMap_Heterogeneous_BleedingEdge(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val.hashCode(); + + return new TrieMap_Heterogeneous_BleedingEdge(newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __putAll( + final Map map) { + final io.usethesource.capsule.Map.Transient tmpTransient = this + .asTransient(); + tmpTransient.__putAll(map); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Map.Immutable __putAllEquivalent( + final Map map, final Comparator cmp) { + final io.usethesource.capsule.Map.Transient tmpTransient = this + .asTransient(); + tmpTransient.__putAllEquivalent(map, cmp); + return tmpTransient.freeze(); + } + + public io.usethesource.capsule.Map.Immutable __remove(final int key) { + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getInt(); + return new TrieMap_Heterogeneous_BleedingEdge(newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); + } + + return this; + } + + public io.usethesource.capsule.Map.Immutable __removeEquivalent(final int key, + final Comparator cmp) { + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getInt(); + return new TrieMap_Heterogeneous_BleedingEdge(newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __remove(final Object key) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getObject().hashCode(); + return new TrieMap_Heterogeneous_BleedingEdge(newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __removeEquivalent( + final Object key, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getObject().hashCode(); + return new TrieMap_Heterogeneous_BleedingEdge(newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); + } + + return this; + } + + @Override + public Object put(final Object key, final Object val) { + throw new UnsupportedOperationException(); + } + + @Override + public void putAll(final Map m) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public Object remove(final Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new MapKeyIterator(rootNode); + } + + @Override + public Iterator valueIterator() { + return new MapValueIterator(rootNode); + } + + @Override + public Iterator> entryIterator() { + return new MapEntryIterator(rootNode); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieMap_Heterogeneous_BleedingEdge.this.keyIterator(); + } + + @Override + public int size() { + return TrieMap_Heterogeneous_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_Heterogeneous_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_Heterogeneous_BleedingEdge.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_Heterogeneous_BleedingEdge.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieMap_Heterogeneous_BleedingEdge.this.valueIterator(); + } + + @Override + public int size() { + return TrieMap_Heterogeneous_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_Heterogeneous_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_Heterogeneous_BleedingEdge.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TrieMap_Heterogeneous_BleedingEdge.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieMap_Heterogeneous_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_Heterogeneous_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_Heterogeneous_BleedingEdge.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_Heterogeneous_BleedingEdge.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieMap_Heterogeneous_BleedingEdge) { + TrieMap_Heterogeneous_BleedingEdge that = (TrieMap_Heterogeneous_BleedingEdge) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final Object key = (Object) entry.getKey(); + final Optional result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + final Object val = (Object) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public io.usethesource.capsule.Map.Transient asTransient() { + return new TransientTrieMap_Heterogeneous_BleedingEdge(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractMapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator nodeIterator() { + return new TrieMap_Heterogeneous_BleedingEdgeNodeIterator(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. + */ + protected int[][] arityCombinationsHistogram() { + final Iterator it = nodeIterator(); + final int[][] sumArityCombinations = new int[9][9]; + + while (it.hasNext()) { + final AbstractMapNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[9]; + + final int maxArity = 8; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[9]; + for (int cumsum = 0, i = 0; i < 9; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 9; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + abstract static class Optional { + + private static final Optional EMPTY = new Optional() { + @Override + boolean isPresent() { + return false; + } + + @Override + Object get() { + return null; + } + }; + + static Optional empty() { + return EMPTY; + } + + static Optional of(T value) { + return new Value(value); + } + + abstract boolean isPresent(); + + abstract T get(); + + private static final class Value extends Optional { + + private final T value; + + private Value(T value) { + this.value = value; + } + + @Override + boolean isPresent() { + return true; + } + + @Override + T get() { + return value; + } + } + } + + static final class MapResult { + + private EitherIntOrObject replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(EitherIntOrObject replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static MapResult unchanged() { + return new MapResult(); + } + + private MapResult() { + } + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public EitherIntOrObject getReplacedValue() { + return replacedValue; + } + } + + protected static interface INode { + + } + + protected abstract static class AbstractMapNode { + + protected static final sun.misc.Unsafe initializeUnsafe() { + try { + Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe"); + field.setAccessible(true); + return (sun.misc.Unsafe) field.get(null); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + protected static final sun.misc.Unsafe unsafe = initializeUnsafe(); + + protected static final int TUPLE_LENGTH = 2; + + protected static final boolean isAllowedToEdit(final AtomicReference x, + final AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean containsKey(final int key, final int keyHash, final int shift); + + abstract boolean containsKeyEquivalent(final int key, final int keyHash, final int shift, + final Comparator cmp); + + abstract boolean containsKey(final Object key, final int keyHash, final int shift); + + abstract boolean containsKeyEquivalent(final Object key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final int key, final int keyHash, final int shift); + + abstract Optional findByKey(final int key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final Object key, final int keyHash, final int shift); + + abstract Optional findByKey(final Object key, final int keyHash, final int shift, + final Comparator cmp); + + abstract AbstractMapNode updated(final AtomicReference mutator, final int key, + final int val, final int keyHash, final int shift, final MapResult details); + + abstract AbstractMapNode updated(final AtomicReference mutator, final int key, + final int val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + abstract AbstractMapNode updated(final AtomicReference mutator, final Object key, + final Object val, final int keyHash, final int shift, final MapResult details); + + abstract AbstractMapNode updated(final AtomicReference mutator, final Object key, + final Object val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + abstract public AbstractMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details); + + abstract public AbstractMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp); + + abstract public AbstractMapNode removed(final AtomicReference mutator, final Object key, + final int keyHash, final int shift, final MapResult details); + + abstract public AbstractMapNode removed(final AtomicReference mutator, final Object key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp); + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractMapNode getNode(final int index); + + Iterator nodeIterator() { + return new Iterator() { + int nextIndex = 0; + final int nodeArity = AbstractMapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractMapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract int rarePayloadArity(); + + abstract int getKey(final int index); + + abstract int getVal(final int index); + + abstract Map.Entry getKeyValueEntry(final int index); + + abstract Object getRareKey(final int index); + + abstract Object getRareVal(final int index); + + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + abstract int untypedSlotArity(); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + int size() { + final Iterator it = new MapKeyIterator(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + ; + return size; + } + + static final byte sizeEmpty() { + return 0b0; + } + + static final byte sizeOne() { + return 0b1; + } + + static final byte sizeMoreThanOne() { + return 0b10; + } + + byte sizePredicate() { + if (this.nodeArity() == 0) { + switch (this.payloadArity() + this.rarePayloadArity()) { + case 0: + return sizeEmpty(); + case 1: + return sizeOne(); + default: + return sizeMoreThanOne(); + } + } else { + return sizeMoreThanOne(); + } + } + + abstract public boolean equals(final Object other); + + abstract public String toString(); + } + + protected abstract static class CompactMapNode extends AbstractMapNode { + + protected CompactMapNode(final AtomicReference mutator, final byte rawMap1, + final byte rawMap2) { + this.rawMap1 = rawMap1; + this.rawMap2 = rawMap2; + } + + static final long initializeArrayBase() { + try { + // assuems that both are of type Object and next to each other in memory + return DataLayoutHelper.arrayOffsets[0]; + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + static final long arrayBase = initializeArrayBase(); + + static final long initializeAddressSize() { + try { + // assuems that both are of type Object and next to each other in memory + return DataLayoutHelper.arrayOffsets[1] - DataLayoutHelper.arrayOffsets[0]; + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + static final long addressSize = initializeAddressSize(); + + static final Class[][] initializeSpecializationsByContentAndNodes() { + Class[][] next = new Class[33][65]; + + try { + for (int m = 0; m <= 32; m++) { + for (int n = 0; n <= 64; n++) { + int mNext = m; + int nNext = n; + + // TODO: last expression is not properly generated yet and maybe incorrect + if (mNext < 0 || mNext > 32 || nNext < 0 || nNext > 64 + || Math.ceil(nNext / 2.0) + mNext > 8) { + next[m][n] = null; + } else { + next[m][n] = Class.forName(String.format( + "io.usethesource.capsule.experimental.heterogeneous.TrieMap_Heterogeneous_BleedingEdge_Specializations$Map%dTo%dNode_Heterogeneous_BleedingEdge", + mNext, nNext)); + } + } + } + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } + + return next; + } + + static final Class[][] specializationsByContentAndNodes = + initializeSpecializationsByContentAndNodes(); + + static long globalRawMap1Offset = + fieldOffset(Map0To2Node_Heterogeneous_BleedingEdge.class, "rawMap1"); + + static long globalRawMap2Offset = + fieldOffset(Map0To2Node_Heterogeneous_BleedingEdge.class, "rawMap2"); + + static long globalArrayOffsetsOffset = + fieldOffset(Map0To2Node_Heterogeneous_BleedingEdge.class, "arrayOffsets"); + + static long globalNodeArityOffset = + fieldOffset(Map0To2Node_Heterogeneous_BleedingEdge.class, "nodeArity"); + + static long globalPayloadArityOffset = + fieldOffset(Map0To2Node_Heterogeneous_BleedingEdge.class, "payloadArity"); + + static long globalSlotArityOffset = + fieldOffset(Map0To2Node_Heterogeneous_BleedingEdge.class, "slotArity"); + + static long globalUntypedSlotArityOffset = + fieldOffset(Map0To2Node_Heterogeneous_BleedingEdge.class, "untypedSlotArity"); + + static long globalRareBaseOffset = + fieldOffset(Map0To2Node_Heterogeneous_BleedingEdge.class, "rareBase"); + + static long globalArrayOffsetLastOffset = + fieldOffset(Map0To2Node_Heterogeneous_BleedingEdge.class, "arrayOffsetLast"); + + static long globalNodeBaseOffset = + fieldOffset(Map0To2Node_Heterogeneous_BleedingEdge.class, "nodeBase"); + + Companion getCompanion() { + + Class clazz = this.getClass(); + + int nodeArity = unsafe.getInt(clazz, globalNodeArityOffset); + int payloadArity = unsafe.getInt(clazz, globalPayloadArityOffset); + int slotArity = unsafe.getInt(clazz, globalSlotArityOffset); + int untypedSlotArity = unsafe.getInt(clazz, globalUntypedSlotArityOffset); + long rareBase = unsafe.getLong(clazz, globalRareBaseOffset); + long arrayOffsetLast = unsafe.getLong(clazz, globalArrayOffsetLastOffset); + long nodeBase = unsafe.getLong(clazz, globalNodeBaseOffset); + + return new Companion(nodeArity, payloadArity, slotArity, untypedSlotArity, rareBase, + arrayOffsetLast, nodeBase); + + } + + static final int hashCodeLength() { + return 32; + } + + static final int bitPartitionSize() { + return 3; + } + + static final int bitPartitionMask() { + return 0b111; + } + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & bitPartitionMask(); + } + + static final byte bitpos(final int mask) { + return (byte) (1 << mask); + } + + byte nodeMap() { + return (byte) (Byte.toUnsignedInt(rawMap1()) ^ Byte.toUnsignedInt(rareMap())); + } + + byte dataMap() { + return (byte) (Byte.toUnsignedInt(rawMap2()) ^ Byte.toUnsignedInt(rareMap())); + } + + byte rareMap() { + return (byte) (Byte.toUnsignedInt(rawMap1()) & Byte.toUnsignedInt(rawMap2())); + } + + public byte rawMap1() { + return rawMap1; + } + + private byte rawMap1; + + public byte rawMap2() { + return rawMap2; + } + + private byte rawMap2; + + static final boolean isRare(final Object o) { + throw new UnsupportedOperationException(); // TODO: to implement + } + + static final boolean isRare(final Object o0, final Object o1) { + throw new UnsupportedOperationException(); // TODO: to implement + } + + static final boolean isRare(final byte bitpos) { + throw new UnsupportedOperationException(); // TODO: to implement + } + + static final int getKey(final Class clazz, + final CompactMapNode instance, final int index) { + // TODO: generate global offset for begin of rare payload + // TODO: remove hard-coded sizeOf(int) + + long keyOffset = arrayBase + (TUPLE_LENGTH * index + 0) * 4; + return (int) unsafe.getInt(instance, keyOffset); + + } + + static final Object getRareKey(final Class clazz, + final CompactMapNode instance, final int index) { + // TODO: generate global offset for begin of rare payload + // TODO: remove hard-coded sizeOf(int) + + long rareBase = unsafe.getLong(clazz, globalRareBaseOffset); + long keyOffset = rareBase + (TUPLE_LENGTH * index + 0) * addressSize; + + return (Object) getFromObjectRegion(instance, rareBase, TUPLE_LENGTH * index + 0); + + } + + static final int getVal(final Class clazz, + final CompactMapNode instance, final int index) { + // TODO: generate global offset for begin of rare payload + // TODO: remove hard-coded sizeOf(int) + + long keyOffset = arrayBase + (TUPLE_LENGTH * index + 1) * 4; + return (int) unsafe.getInt(instance, keyOffset); + + } + + static final Object getRareVal(final Class clazz, + final CompactMapNode instance, final int index) { + // TODO: generate global offset for begin of rare payload + // TODO: remove hard-coded sizeOf(int) + + long rareBase = unsafe.getLong(clazz, globalRareBaseOffset); + long keyOffset = rareBase + (TUPLE_LENGTH * index + 1) * addressSize; + + return (Object) getFromObjectRegion(instance, rareBase, TUPLE_LENGTH * index + 1); + + } + + static final AbstractMapNode getNode(final Class clazz, + final CompactMapNode instance, final int index) { + final int untypedSlotArity = unsafe.getInt(clazz, globalUntypedSlotArityOffset); + final long rareBase = unsafe.getLong(clazz, globalRareBaseOffset); + + final int pIndex = untypedSlotArity - 1 - index; + + return (AbstractMapNode) getFromObjectRegion(instance, rareBase, pIndex); + } + + enum ContentType { + KEY, VAL, RARE_KEY, RARE_VAL, NODE, SLOT + } + + int logicalToPhysicalIndex(final ContentType type, final int index) { + final int physicalIndex; + + switch (type) { + case KEY: + physicalIndex = TUPLE_LENGTH * index; + break; + case VAL: + physicalIndex = TUPLE_LENGTH * index + 1; + break; + case RARE_KEY: + physicalIndex = TUPLE_LENGTH * index + + TUPLE_LENGTH * java.lang.Integer.bitCount(Byte.toUnsignedInt(dataMap())); + break; + case RARE_VAL: + physicalIndex = TUPLE_LENGTH * index + + TUPLE_LENGTH * java.lang.Integer.bitCount(Byte.toUnsignedInt(dataMap())) + 1; + break; + case NODE: + physicalIndex = slotArity() - 1 - index; + break; + case SLOT: + physicalIndex = index; + break; + default: + throw new IllegalStateException("Cases not exhausted?"); + } + + return physicalIndex; + } + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == sizeEmpty() : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == sizeOne() : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == sizeMoreThanOne() : true; + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + static final long[] arrayOffsets(final Class clazz, final String[] fieldNames) { + try { + long[] arrayOffsets = new long[fieldNames.length]; + + for (int i = 0; i < fieldNames.length; i++) { + arrayOffsets[i] = unsafe.objectFieldOffset(clazz.getDeclaredField(fieldNames[i])); + } + + return arrayOffsets; + } catch (NoSuchFieldException | SecurityException e) { + throw new RuntimeException(e); + } + } + + static final long fieldOffset(final Class clazz, final String fieldName) { + try { + List bottomUpHierarchy = new LinkedList<>(); + + Class currentClass = clazz; + while (currentClass != null) { + bottomUpHierarchy.add(currentClass); + currentClass = currentClass.getSuperclass(); + } + + final java.util.Optional fieldNameField = bottomUpHierarchy.stream() + .flatMap(hierarchyClass -> Stream.of(hierarchyClass.getDeclaredFields())) + .filter(f -> f.getName().equals(fieldName)).findFirst(); + + if (fieldNameField.isPresent()) { + + if (java.lang.reflect.Modifier.isStatic(fieldNameField.get().getModifiers())) { + return unsafe.staticFieldOffset(fieldNameField.get()); + } else { + return unsafe.objectFieldOffset(fieldNameField.get()); + } + } else { + return sun.misc.Unsafe.INVALID_FIELD_OFFSET; + } + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + static final CompactMapNode allocateHeapRegion(final Class clazz) { + try { + final Object newInstance = unsafe.allocateInstance(clazz); + return (CompactMapNode) newInstance; + } catch (ClassCastException | InstantiationException e) { + throw new RuntimeException(e); + } + } + + static final CompactMapNode allocateHeapRegion(final int dim1, final int dim2) { + final Class clazz = specializationsByContentAndNodes[dim1][dim2]; + return allocateHeapRegion(clazz); + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final byte bitpos, + final int index, final int val) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(srcClass); + + dst.rawMap1 = rawMap1; + + dst.rawMap2 = rawMap2; + + int pIndex = TUPLE_LENGTH * index + 1; + + long offset = arrayBase; + offset += rangecopyIntRegion(src, offset, dst, offset, 2 * payloadArity); + + setInIntRegion(dst, arrayBase, pIndex, val); + + long rareBase = offset; + offset += rangecopyObjectRegion(src, offset, dst, offset, untypedSlotArity); + + /* + * final int pIndex = TUPLE_LENGTH * index + 1; + * + * rangecopyPrimitiveRegion(src, arrayBase, dst, arrayBase, primitiveRegionSize); + * setInIntRegion(dst, arrayBase, pIndex, val); + * + * rangecopyObjectRegion(src, rareBase, 0, dst, rareBase, 0, untypedSlotArity); + */ + + return dst; + } + + CompactMapNode copyAndSetRareValue(final AtomicReference mutator, final byte bitpos, + final int index, final Object val) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(srcClass); + + dst.rawMap1 = rawMap1; + + dst.rawMap2 = rawMap2; + + int pIndex = TUPLE_LENGTH * index + 1; + + long offset = arrayBase; + offset += rangecopyIntRegion(src, offset, dst, offset, 2 * payloadArity); + + long rareBase = offset; + offset += rangecopyObjectRegion(src, offset, dst, offset, untypedSlotArity); + + setInObjectRegion(dst, rareBase, pIndex, val); + + /* + * final int pIndex = TUPLE_LENGTH * index + 1; + * + * rangecopyPrimitiveRegion(src, arrayBase, dst, arrayBase, primitiveRegionSize); + * + * rangecopyObjectRegion(src, rareBase, 0, dst, rareBase, 0, untypedSlotArity); + * setInObjectRegion(dst, rareBase, pIndex, val); + */ + + return dst; + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final byte bitpos, + final int index, final int key, final int val) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(payloadArity + 1, untypedSlotArity); + + dst.rawMap1 = rawMap1; + dst.rawMap2 = (byte) (rawMap2 | bitpos); + + final int pIndex = TUPLE_LENGTH * index; + + int typedSlotArity = payloadArity * 2; + + long offset = arrayBase; + long delta = 0; + + offset += rangecopyIntRegion(src, offset, dst, offset, pIndex); + delta += setInIntRegionVarArgs(dst, offset, key, val); + offset += rangecopyIntRegion(src, offset, dst, offset + delta, typedSlotArity - pIndex); + offset += rangecopyObjectRegion(src, offset, dst, offset + delta, untypedSlotArity); + + return dst; + } + + CompactMapNode copyAndInsertRareValue(final AtomicReference mutator, final byte bitpos, + final int index, final Object key, final Object val) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(payloadArity, untypedSlotArity + TUPLE_LENGTH); + + dst.rawMap1 = (byte) (rawMap1 | bitpos); + dst.rawMap2 = (byte) (rawMap2 | bitpos); + + final int pIndex = TUPLE_LENGTH * index; + + long offset = arrayBase; + long delta = 0; + + offset += rangecopyIntRegion(src, offset, dst, offset, 2 * payloadArity); + offset += rangecopyObjectRegion(src, offset, dst, offset, pIndex); + delta += setInObjectRegionVarArgs(dst, offset, key, val); + offset += rangecopyObjectRegion(src, offset, dst, offset + delta, untypedSlotArity - pIndex); + + return dst; + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final byte bitpos) { + final int valIdx = dataIndex(bitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(payloadArity - 1, untypedSlotArity); + + long srcOffset = arrayBase; + long dstOffset = arrayBase; + + dst.rawMap1 = unsafe.getByte(src, globalRawMap1Offset); + + dst.rawMap2 = (byte) (unsafe.getByte(src, globalRawMap2Offset) ^ bitpos); + + for (int i = 0; i < valIdx; i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + } + srcOffset += 4; + srcOffset += 4; + for (int i = valIdx + 1; i < payloadArity(); i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + } + for (int i = 0; i < rarePayloadArity(); i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + for (int i = nodeArity() - 1; i >= 0; i--) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + + return dst; + } + + CompactMapNode copyAndRemoveRareValue(final AtomicReference mutator, + final byte bitpos) { + final int valIdx = rareIndex(bitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(payloadArity, untypedSlotArity - TUPLE_LENGTH); + + long srcOffset = arrayBase; + long dstOffset = arrayBase; + + dst.rawMap1 = unsafe.getByte(src, globalRawMap1Offset); + + dst.rawMap2 = (byte) (unsafe.getByte(src, globalRawMap2Offset) ^ bitpos); + + for (int i = 0; i < payloadArity(); i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + } + for (int i = 0; i < valIdx; i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + srcOffset += addressSize; + srcOffset += addressSize; + for (int i = valIdx + 1; i < rarePayloadArity(); i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + for (int i = nodeArity() - 1; i >= 0; i--) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + + return dst; + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int index, + final AbstractMapNode node) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.rawMap1 = rawMap1; + dst.rawMap2 = rawMap2; + + /* + * rangecopyPrimitiveRegion(src, arrayBase, dst, arrayBase, primitiveRegionSize); + * + * rangecopyObjectRegion(src, rareBase, 0, dst, rareBase, 0, untypedSlotArity); + * setInObjectRegion(dst, rareBase, untypedSlotArity - 1 - index, node); + */ + + int pIndex = untypedSlotArity - 1 - index; + + long offset = arrayBase; + offset += rangecopyIntRegion(src, offset, dst, offset, 2 * payloadArity); + + long rareBase = offset; + offset += rangecopyObjectRegion(src, offset, dst, offset, untypedSlotArity); + + setInObjectRegion(dst, rareBase, pIndex, node); + + return dst; + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final byte bitpos, final int indexOld, final int indexNew, final AbstractMapNode node) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = allocateHeapRegion(payloadArity - 1, untypedSlotArity + 1); + + // idempotent operation; in case of rare bit was already set before + dst.rawMap1 = (byte) (rawMap1 | bitpos); + dst.rawMap2 = (byte) (rawMap2 ^ bitpos); + + final int pIndexOld = TUPLE_LENGTH * indexOld; + final int pIndexNew = (untypedSlotArity + 1) - 1 - indexNew; + + long offset = arrayBase; + offset += rangecopyIntRegion(src, offset, dst, offset, pIndexOld); + long delta = 2 * 4 /* sizeOfInt() */; + offset += rangecopyIntRegion(src, offset + delta, dst, offset, + (TUPLE_LENGTH * (payloadArity - 1) - pIndexOld)); + + offset += rangecopyObjectRegion(src, offset + delta, dst, offset, pIndexNew); + long delta2 = setInObjectRegionVarArgs(dst, offset, node); + delta -= delta2; + offset += delta2; + offset += + rangecopyObjectRegion(src, offset + delta, dst, offset, untypedSlotArity - pIndexNew); + + return dst; + } + + CompactMapNode copyAndMigrateFromRareInlineToNode(final AtomicReference mutator, + final byte bitpos, final int indexOld, final int indexNew, final AbstractMapNode node) { + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = + allocateHeapRegion(payloadArity, untypedSlotArity - TUPLE_LENGTH + 1); + + // idempotent operation; in case of rare bit was already set before + dst.rawMap1 = (byte) (rawMap1 | bitpos); + dst.rawMap2 = (byte) (rawMap2 ^ bitpos); + + final int pIndexOld = TUPLE_LENGTH * indexOld; + final int pIndexNew = (untypedSlotArity - TUPLE_LENGTH + 1) - 1 - indexNew; + + long offset = arrayBase; + offset += rangecopyIntRegion(src, arrayBase, dst, arrayBase, 2 * payloadArity); + + offset += rangecopyObjectRegion(src, offset, dst, offset, pIndexOld); + long delta = 2 * sizeOfObject(); + offset += rangecopyObjectRegion(src, offset + delta, dst, offset, pIndexNew - pIndexOld); + long delta2 = setInObjectRegionVarArgs(dst, offset, node); + delta -= delta2; + offset += delta2; + offset += + rangecopyObjectRegion(src, offset + delta, dst, offset, untypedSlotArity - pIndexNew - 2); + + return dst; + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final byte bitpos, final AbstractMapNode node) { + final int idxOld = nodeIndex(bitpos); + final int idxNew = dataIndex(bitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = + allocateHeapRegion(payloadArity + 1, untypedSlotArity - TUPLE_LENGTH); + + long srcOffset = arrayBase; + long dstOffset = arrayBase; + + // idempotent operation; in case of rare bit was already set before + dst.rawMap1 = (byte) (unsafe.getByte(src, globalRawMap1Offset) ^ bitpos); + + dst.rawMap2 = (byte) (unsafe.getByte(src, globalRawMap2Offset) | bitpos); + + for (int i = 0; i < idxNew; i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + } + unsafe.putInt(dst, dstOffset, node.getKey(0)); + dstOffset += 4; + unsafe.putInt(dst, dstOffset, node.getVal(0)); + dstOffset += 4; + for (int i = idxNew; i < payloadArity(); i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + } + for (int i = 0; i < rarePayloadArity(); i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + for (int i = nodeArity() - 1; i >= idxOld + 1; i--) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + srcOffset += addressSize; + for (int i = idxOld - 1; i >= 0; i--) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + + return dst; + } + + CompactMapNode copyAndMigrateFromNodeToRareInline(final AtomicReference mutator, + final byte bitpos, final AbstractMapNode node) { + final int idxOld = nodeIndex(bitpos); + final int idxNew = rareIndex(bitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = unsafe.getInt(srcClass, globalPayloadArityOffset); + final int untypedSlotArity = unsafe.getInt(srcClass, globalUntypedSlotArityOffset); + + final CompactMapNode src = this; + final CompactMapNode dst = + allocateHeapRegion(payloadArity, untypedSlotArity + TUPLE_LENGTH - 1); + + long srcOffset = arrayBase; + long dstOffset = arrayBase; + + // idempotent operation; in case of rare bit was already set before + dst.rawMap1 = (byte) (unsafe.getByte(src, globalRawMap1Offset) | bitpos); + + dst.rawMap2 = (byte) (unsafe.getByte(src, globalRawMap2Offset) | bitpos); + + for (int i = 0; i < payloadArity(); i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += 4; + dstOffset += 4; + } + for (int i = 0; i < idxNew; i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + unsafe.putObject(dst, dstOffset, node.getRareKey(0)); + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, node.getRareVal(0)); + dstOffset += addressSize; + for (int i = idxNew; i < rarePayloadArity(); i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + for (int i = nodeArity() - 1; i >= idxOld + 1; i--) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + srcOffset += addressSize; + for (int i = idxOld - 1; i >= 0; i--) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + + return dst; + } + + static final AbstractMapNode mergeTwoKeyValPairs(final Object key0, final Object val0, + final int keyHash0, final Object key1, final Object val1, final int keyHash1, + final int shift) { + // assert !(key0 == key1); + + if (shift >= hashCodeLength()) { + return new HashCollisionMapNode_Heterogeneous_BleedingEdge(keyHash0, + (Object[]) new Object[]{key0, key1}, (Object[]) new Object[]{val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final byte nodeMap = (byte) (bitpos(mask0) | bitpos(mask1)); + final byte dataMap = (byte) (bitpos(mask0) | bitpos(mask1)); + + if (mask0 < mask1) { + return nodeOf4x0(null, (byte) nodeMap, dataMap, key0, val0, key1, val1); + } else { + return nodeOf4x0(null, (byte) nodeMap, dataMap, key1, val1, key0, val0); + } + } else { + final AbstractMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, keyHash1, + shift + bitPartitionSize()); + // values fit on next level + + final byte nodeMap = bitpos(mask0); + return nodeOf1x0(null, nodeMap, (byte) 0, node); + } + } + + static final AbstractMapNode mergeTwoKeyValPairs(final Object key0, final Object val0, + final int keyHash0, final int key1, final int val1, final int keyHash1, final int shift) { + // assert !(key0 == key1); + + if (shift >= hashCodeLength()) { + return new HashCollisionMapNode_Heterogeneous_BleedingEdge(keyHash0, + (Object[]) new Object[]{key0, key1}, (Object[]) new Object[]{val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final byte nodeMap = (byte) (bitpos(mask0)); + final byte dataMap = (byte) (bitpos(mask0) | bitpos(mask1)); + + // convention: rare after base + return nodeOf2x1(null, (byte) nodeMap, dataMap, key1, val1, key0, val0); + } else { + final AbstractMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, keyHash1, + shift + bitPartitionSize()); + // values fit on next level + + final byte nodeMap = bitpos(mask0); + return nodeOf1x0(null, nodeMap, (byte) 0, node); + } + } + + static final AbstractMapNode mergeTwoKeyValPairs(final int key0, final int val0, + final int keyHash0, final Object key1, final Object val1, final int keyHash1, + final int shift) { + // assert !(key0 == key1); + + if (shift >= hashCodeLength()) { + return new HashCollisionMapNode_Heterogeneous_BleedingEdge(keyHash0, + (Object[]) new Object[]{key0, key1}, (Object[]) new Object[]{val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final byte nodeMap = (byte) (bitpos(mask1)); + final byte dataMap = (byte) (bitpos(mask0) | bitpos(mask1)); + + // convention: rare after base + return nodeOf2x1(null, (byte) nodeMap, dataMap, key0, val0, key1, val1); + } else { + final AbstractMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, keyHash1, + shift + bitPartitionSize()); + // values fit on next level + + final byte nodeMap = bitpos(mask0); + return nodeOf1x0(null, nodeMap, (byte) 0, node); + } + } + + static final AbstractMapNode mergeTwoKeyValPairs(final int key0, final int val0, + final int keyHash0, final int key1, final int val1, final int keyHash1, final int shift) { + // assert !(key0 == key1); + + if (shift >= hashCodeLength()) { + return new HashCollisionMapNode_Heterogeneous_BleedingEdge(keyHash0, + (Object[]) new Object[]{key0, key1}, (Object[]) new Object[]{val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final byte nodeMap = 0; + final byte dataMap = (byte) (bitpos(mask0) | bitpos(mask1)); + + if (mask0 < mask1) { + return nodeOf0x2(null, (byte) nodeMap, dataMap, key0, val0, key1, val1); + } else { + return nodeOf0x2(null, (byte) nodeMap, dataMap, key1, val1, key0, val0); + } + } else { + final AbstractMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, keyHash1, + shift + bitPartitionSize()); + // values fit on next level + + final byte nodeMap = bitpos(mask0); + return nodeOf1x0(null, nodeMap, (byte) 0, node); + } + } + + static final int index(final byte bitmap, final byte bitpos) { + return java.lang.Integer.bitCount(Byte.toUnsignedInt(bitmap) & (bitpos - 1)); + } + + static final int index(final byte bitmap, final int mask, final byte bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final byte bitpos) { + return java.lang.Integer.bitCount(Byte.toUnsignedInt(dataMap()) & (bitpos - 1)); + } + + int nodeIndex(final byte bitpos) { + return java.lang.Integer.bitCount(Byte.toUnsignedInt(nodeMap()) & (bitpos - 1)); + } + + int rareIndex(final byte bitpos) { + return java.lang.Integer.bitCount(Byte.toUnsignedInt(rareMap()) & (bitpos - 1)); + } + + AbstractMapNode nodeAt(final byte bitpos) { + return getNode(nodeIndex(bitpos)); + } + + private static final boolean equals(final Object o1, final Object o2) { + if (null == o1 || null == o2) { + return false; + } + if (o1 == o2) { + return true; + } + if (o1.getClass() != o2.getClass()) { + return false; + } + + final CompactMapNode src = (CompactMapNode) o1; + final CompactMapNode dst = (CompactMapNode) o2; + + final Class clazz = o1.getClass(); + final long[] arrayOffsets = (long[]) unsafe.getObject(clazz, globalArrayOffsetsOffset); + + // compare rawMap1 + if (!(unsafe.getByte(src, globalRawMap1Offset) == unsafe.getByte(dst, globalRawMap1Offset))) { + return false; + } + + // compare rawMap2 + if (!(unsafe.getByte(src, globalRawMap2Offset) == unsafe.getByte(dst, globalRawMap2Offset))) { + return false; + } + + // compare payload range + for (int i = 0; i < src.payloadArity(); i++) { + if (!(unsafe.getInt(src, + arrayOffsets[src.logicalToPhysicalIndex(ContentType.KEY, i)]) == unsafe.getInt(dst, + arrayOffsets[dst.logicalToPhysicalIndex(ContentType.KEY, i)]))) { + return false; + } + + if (!(unsafe.getInt(src, + arrayOffsets[src.logicalToPhysicalIndex(ContentType.VAL, i)]) == unsafe.getInt(dst, + arrayOffsets[dst.logicalToPhysicalIndex(ContentType.VAL, i)]))) { + return false; + } + } + + // compare node range + for (int i = 0; i < src.nodeArity(); i++) { + if (!(unsafe.getObject(src, arrayOffsets[src.logicalToPhysicalIndex(ContentType.NODE, i)]) + .equals(unsafe.getObject(dst, + arrayOffsets[dst.logicalToPhysicalIndex(ContentType.NODE, i)])))) { + return false; + } + } + + return true; + } + + static final byte recoverMask(int map, final byte i_th) { + assert 1 <= i_th && i_th <= 8; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 8) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = (byte) (map >> 1); + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getKey(i)), + Objects.hashCode(getVal(i)))); + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + bldr.append(']'); + return bldr.toString(); + } + + static final AbstractMapNode nodeOf1x0(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0) { + return new Map0To1Node_Heterogeneous_BleedingEdge(mutator, nodeMap, dataMap, slot0); + } + + static final AbstractMapNode nodeOf0x1(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1) { + return new Map1To0Node_Heterogeneous_BleedingEdge(mutator, nodeMap, dataMap, key1, val1); + } + + static final AbstractMapNode nodeOf0x2(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2) { + return new Map2To0Node_Heterogeneous_BleedingEdge(mutator, nodeMap, dataMap, key1, val1, key2, + val2); + } + + static final AbstractMapNode nodeOf4x0(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + return new Map0To4Node_Heterogeneous_BleedingEdge(mutator, nodeMap, dataMap, slot0, slot1, + slot2, slot3); + } + + static final AbstractMapNode nodeOf2x0(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1) { + return new Map0To2Node_Heterogeneous_BleedingEdge(mutator, nodeMap, dataMap, slot0, slot1); + } + + static final AbstractMapNode nodeOf2x1(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1) { + return new Map1To2Node_Heterogeneous_BleedingEdge(mutator, nodeMap, dataMap, key1, val1, + slot0, slot1); + } + + @Override + boolean containsKeyEquivalent(final int key, final int keyHash, final int shift, + final Comparator cmp) { + CompactMapNode instance = this; + Class clazz = instance.getClass(); + + for (int shift0 = shift; true; shift0 += bitPartitionSize()) { + final int mask = mask(keyHash, shift0); + final byte bitpos = bitpos(mask); + + final byte nodeMap = instance.nodeMap(); + // final byte nodeMap = unsafe.getByte(instance, globalRawMap1Offset); + if (isBitInBitmap(nodeMap, bitpos)) { + final int index = index(nodeMap, mask, bitpos); + final AbstractMapNode nestedInstance = getNode(clazz, instance, index); + + try { + instance = (CompactMapNode) nestedInstance; + clazz = instance.getClass(); + } catch (ClassCastException unused) { + return ((HashCollisionMapNode_Heterogeneous_BleedingEdge) nestedInstance) + .containsKey(key, keyHash, 0); + } + } else { + final byte dataMap = instance.dataMap(); + // final byte dataMap = unsafe.getByte(instance, globalRawMap2Offset); + if (isBitInBitmap(dataMap, bitpos)) { + final int index = index(dataMap, mask, bitpos); + return getKey(clazz, instance, index) == key; + } else { + return false; + } + } + } + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final byte bitpos = bitpos(mask); + + byte rawMap1 = this.rawMap1; + byte rawMap2 = this.rawMap2; + + final byte rareMap = (byte) (Byte.toUnsignedInt(rawMap1) & Byte.toUnsignedInt(rawMap2)); + final byte dataMap = (byte) (Byte.toUnsignedInt(rawMap2) ^ Byte.toUnsignedInt(rareMap)); + final byte nodeMap = (byte) (Byte.toUnsignedInt(rawMap1) ^ Byte.toUnsignedInt(rareMap)); + + final int nodeIndex = index(nodeMap, mask, bitpos); + + // check for node (not value) + if (isBitInBitmap(nodeMap, bitpos)) { + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + bitPartitionSize(), details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } else + // check for inplace (rare) value + if (isBitInBitmap(rareMap, bitpos)) { + final int rareIndex = index(rareMap, mask, bitpos); + final Object currentKey = getRareKey(rareIndex); + + final Object currentVal = getRareVal(rareIndex); + + final AbstractMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromRareInlineToNode(mutator, bitpos, rareIndex, nodeIndex, + subNodeNew); + + } else + // check for inplace value + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + final int currentVal = getVal(dataIndex); + + // update mapping + details.updated(EitherIntOrObject.ofInt(currentVal)); + return copyAndSetValue(mutator, bitpos, dataIndex, val); + } else { + final int currentVal = getVal(dataIndex); + + final AbstractMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey), key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, dataIndex, nodeIndex, + subNodeNew); + } + + } else { + // no value + details.modified(); + int dataIndex = index(dataMap, mask, bitpos); + return copyAndInsertValue(mutator, bitpos, dataIndex, key, val); + } + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final byte bitpos = bitpos(mask); + + byte rawMap1 = this.rawMap1; + byte rawMap2 = this.rawMap2; + + final byte rareMap = (byte) (Byte.toUnsignedInt(rawMap1) & Byte.toUnsignedInt(rawMap2)); + final byte dataMap = (byte) (Byte.toUnsignedInt(rawMap2) ^ Byte.toUnsignedInt(rareMap)); + final byte nodeMap = (byte) (Byte.toUnsignedInt(rawMap1) ^ Byte.toUnsignedInt(rareMap)); + + final int nodeIndex = index(nodeMap, mask, bitpos); + + // check for node (not value) + if (isBitInBitmap(nodeMap, bitpos)) { + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + bitPartitionSize(), details); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } else + // check for inplace (rare) value + if (isBitInBitmap(rareMap, bitpos)) { + final int rareIndex = index(rareMap, mask, bitpos); + final Object currentKey = getRareKey(rareIndex); + + final Object currentVal = getRareVal(rareIndex); + + final AbstractMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromRareInlineToNode(mutator, bitpos, rareIndex, nodeIndex, + subNodeNew); + + } else + // check for inplace value + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + final int currentVal = getVal(dataIndex); + + // update mapping + details.updated(EitherIntOrObject.ofInt(currentVal)); + return copyAndSetValue(mutator, bitpos, dataIndex, val); + } else { + final int currentVal = getVal(dataIndex); + + final AbstractMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey), key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, dataIndex, nodeIndex, + subNodeNew); + } + + } else { + // no value + details.modified(); + int dataIndex = index(dataMap, mask, bitpos); + return copyAndInsertValue(mutator, bitpos, dataIndex, key, val); + } + } + + @Override + Map.Entry getKeyValueEntry(final int index) { + return entryOf(getKey(index), getVal(index)); + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final Object key, + final Object val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final byte bitpos = bitpos(mask); + + byte rawMap1 = this.rawMap1; + byte rawMap2 = this.rawMap2; + + final byte rareMap = (byte) (Byte.toUnsignedInt(rawMap1) & Byte.toUnsignedInt(rawMap2)); + final byte dataMap = (byte) (Byte.toUnsignedInt(rawMap2) ^ Byte.toUnsignedInt(rareMap)); + final byte nodeMap = (byte) (Byte.toUnsignedInt(rawMap1) ^ Byte.toUnsignedInt(rareMap)); + + final int nodeIndex = index(nodeMap, mask, bitpos); + + // check for node (not value) + if (isBitInBitmap(nodeMap, bitpos)) { + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + bitPartitionSize(), details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } else + // check for inplace (rare) value + if (isBitInBitmap(rareMap, bitpos)) { + final int rareIndex = index(rareMap, mask, bitpos); + final Object currentKey = getRareKey(rareIndex); + + if (cmp.compare(currentKey, key) == 0) { + final Object currentVal = getRareVal(rareIndex); + + // update mapping + details.updated(EitherIntOrObject.ofObject(currentVal)); + return copyAndSetRareValue(mutator, bitpos, rareIndex, val); + } else { + final Object currentVal = getRareVal(rareIndex); + + final AbstractMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromRareInlineToNode(mutator, bitpos, rareIndex, nodeIndex, + subNodeNew); + } + + } else + // check for inplace value + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final int currentKey = getKey(dataIndex); + + final int currentVal = getVal(dataIndex); + + final AbstractMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey), key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, dataIndex, nodeIndex, + subNodeNew); + + } else { + // no value + details.modified(); + int rareIndex = index(rareMap, mask, bitpos); + return copyAndInsertRareValue(mutator, bitpos, rareIndex, key, val); + } + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final Object key, + final Object val, final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final byte bitpos = bitpos(mask); + + byte rawMap1 = this.rawMap1; + byte rawMap2 = this.rawMap2; + + final byte rareMap = (byte) (Byte.toUnsignedInt(rawMap1) & Byte.toUnsignedInt(rawMap2)); + final byte dataMap = (byte) (Byte.toUnsignedInt(rawMap2) ^ Byte.toUnsignedInt(rareMap)); + final byte nodeMap = (byte) (Byte.toUnsignedInt(rawMap1) ^ Byte.toUnsignedInt(rareMap)); + + final int nodeIndex = index(nodeMap, mask, bitpos); + + // check for node (not value) + if (isBitInBitmap(nodeMap, bitpos)) { + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + bitPartitionSize(), details); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } else + // check for inplace (rare) value + if (isBitInBitmap(rareMap, bitpos)) { + final int rareIndex = index(rareMap, mask, bitpos); + final Object currentKey = getRareKey(rareIndex); + + if (currentKey.equals(key)) { + final Object currentVal = getRareVal(rareIndex); + + // update mapping + details.updated(EitherIntOrObject.ofObject(currentVal)); + return copyAndSetRareValue(mutator, bitpos, rareIndex, val); + } else { + final Object currentVal = getRareVal(rareIndex); + + final AbstractMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromRareInlineToNode(mutator, bitpos, rareIndex, nodeIndex, + subNodeNew); + } + + } else + // check for inplace value + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final int currentKey = getKey(dataIndex); + + final int currentVal = getVal(dataIndex); + + final AbstractMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey), key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, dataIndex, nodeIndex, + subNodeNew); + + } else { + // no value + details.modified(); + int rareIndex = index(rareMap, mask, bitpos); + return copyAndInsertRareValue(mutator, bitpos, rareIndex, key, val); + } + } + + @Override + Optional findByKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final byte bitpos = bitpos(mask); + + final byte dataMap = this.dataMap(); + if (isBitInBitmap(dataMap, bitpos)) { // inplace value + final int index = index(dataMap, mask, bitpos); + + if (getKey(index) == key) { + final Object result = getVal(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + bitPartitionSize(), cmp); + } + + return Optional.empty(); + } + + @Override + int getKey(final int index) { + return getKey(this.getClass(), this, index); + } + + @Override + Object getRareKey(final int index) { + return getRareKey(this.getClass(), this, index); + } + + @Override + boolean containsKeyEquivalent(final Object key, final int keyHash, final int shift, + final Comparator cmp) { + CompactMapNode instance = this; + Class clazz = instance.getClass(); + + for (int shift0 = shift; true; shift0 += bitPartitionSize()) { + final int mask = mask(keyHash, shift0); + final byte bitpos = bitpos(mask); + + final byte nodeMap = instance.nodeMap(); + // final byte nodeMap = unsafe.getByte(instance, globalRawMap1Offset); + if (isBitInBitmap(nodeMap, bitpos)) { + final int index = index(nodeMap, mask, bitpos); + final AbstractMapNode nestedInstance = getNode(clazz, instance, index); + + try { + instance = (CompactMapNode) nestedInstance; + clazz = instance.getClass(); + } catch (ClassCastException unused) { + return ((HashCollisionMapNode_Heterogeneous_BleedingEdge) nestedInstance) + .containsKey(key, keyHash, 0); + } + } else { + final byte rareMap = instance.rareMap(); + // final byte rareMap = unsafe.getByte(instance, globalRawMap2Offset); + if (isBitInBitmap(rareMap, bitpos)) { + final int index = index(rareMap, mask, bitpos); + return cmp.compare(getRareKey(clazz, instance, index), key) == 0; + } else { + return false; + } + } + } + } + + @Override + boolean containsKey(final int key, final int keyHash, final int shift) { + CompactMapNode instance = this; + Class clazz = instance.getClass(); + + for (int shift0 = shift; true; shift0 += bitPartitionSize()) { + final int mask = mask(keyHash, shift0); + final byte bitpos = bitpos(mask); + + final byte nodeMap = instance.nodeMap(); + // final byte nodeMap = unsafe.getByte(instance, globalRawMap1Offset); + if (isBitInBitmap(nodeMap, bitpos)) { + final int index = index(nodeMap, mask, bitpos); + final AbstractMapNode nestedInstance = getNode(clazz, instance, index); + + try { + instance = (CompactMapNode) nestedInstance; + clazz = instance.getClass(); + } catch (ClassCastException unused) { + return ((HashCollisionMapNode_Heterogeneous_BleedingEdge) nestedInstance) + .containsKey(key, keyHash, 0); + } + } else { + final byte dataMap = instance.dataMap(); + // final byte dataMap = unsafe.getByte(instance, globalRawMap2Offset); + if (isBitInBitmap(dataMap, bitpos)) { + final int index = index(dataMap, mask, bitpos); + return getKey(clazz, instance, index) == key; + } else { + return false; + } + } + } + } + + @Override + int untypedSlotArity() { + return unsafe.getInt(this.getClass(), globalUntypedSlotArityOffset); + } + + @Override + Optional findByKey(final Object key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final byte bitpos = bitpos(mask); + + final byte rareMap = this.rareMap(); + if (isBitInBitmap(rareMap, bitpos)) { // inplace value + final int index = index(rareMap, mask, bitpos); + + if (cmp.compare(getRareKey(index), key) == 0) { + final Object result = getRareVal(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + bitPartitionSize(), cmp); + } + + return Optional.empty(); + } + + @Override + Optional findByKey(final int key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final byte bitpos = bitpos(mask); + + final byte dataMap = this.dataMap(); + if (isBitInBitmap(dataMap, bitpos)) { // inplace value + final int index = index(dataMap, mask, bitpos); + + if (getKey(index) == key) { + final Object result = getVal(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + bitPartitionSize()); + } + + return Optional.empty(); + } + + @Override + boolean containsKey(final Object key, final int keyHash, final int shift) { + CompactMapNode instance = this; + Class clazz = instance.getClass(); + + for (int shift0 = shift; true; shift0 += bitPartitionSize()) { + final int mask = mask(keyHash, shift0); + final byte bitpos = bitpos(mask); + + final byte nodeMap = instance.nodeMap(); + // final byte nodeMap = unsafe.getByte(instance, globalRawMap1Offset); + if (isBitInBitmap(nodeMap, bitpos)) { + final int index = index(nodeMap, mask, bitpos); + final AbstractMapNode nestedInstance = getNode(clazz, instance, index); + + try { + instance = (CompactMapNode) nestedInstance; + clazz = instance.getClass(); + } catch (ClassCastException unused) { + return ((HashCollisionMapNode_Heterogeneous_BleedingEdge) nestedInstance) + .containsKey(key, keyHash, 0); + } + } else { + final byte rareMap = instance.rareMap(); + // final byte rareMap = unsafe.getByte(instance, globalRawMap2Offset); + if (isBitInBitmap(rareMap, bitpos)) { + final int index = index(rareMap, mask, bitpos); + return getRareKey(clazz, instance, index).equals(key); + } else { + return false; + } + } + } + } + + @Override + Object getSlot(final int index) { + try { + final long[] arrayOffsets = + (long[]) unsafe.getObject(this.getClass(), globalArrayOffsetsOffset); + return (Object) unsafe.getObject(this, + arrayOffsets[logicalToPhysicalIndex(ContentType.SLOT, index)]); + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + @Override + int payloadArity() { + return unsafe.getInt(this.getClass(), globalPayloadArityOffset); + } + + @Override + boolean hasPayload() { + return payloadArity() != 0; + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final byte bitpos = bitpos(mask); + + // TODO: generalize bitmap declaration/if/index assignment in code generator pattern + // check for inplace value + final byte dataMap = dataMap(); + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + final int currentVal = getVal(dataIndex); + details.updated(EitherIntOrObject.ofInt(currentVal)); + + /* + * Case payload == 2: Create new node with remaining pair. The new node will a) either + * become the new root returned, or b) unwrapped and inlined during returning. + */ + if (this.payloadArity() == 2 && this.rarePayloadArity() == 0 && this.nodeArity() == 0) { + final byte newRawMap = + (shift == 0) ? (byte) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf0x1(mutator, newRawMap, newRawMap, getKey(1 - dataIndex), + getVal(1 - dataIndex)); + } else if (this.payloadArity() == 1 && this.rarePayloadArity() == 1 + && this.nodeArity() == 0) { + final byte newRawMap = + (shift == 0) ? (byte) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf2x0(mutator, (byte) (0), newRawMap, getRareKey(0), getRareVal(0)); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } + + // check for node (not value) + final byte nodeMap = nodeMap(); + if (isBitInBitmap(nodeMap, bitpos)) { + final int nodeIndex = index(nodeMap, mask, bitpos); + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + bitPartitionSize(), details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + if (payloadArity() == 1) { + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToRareInline(mutator, bitpos, subNodeNew); + } + + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + + // no value + return this; + } + + @Override + Optional findByKey(final Object key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final byte bitpos = bitpos(mask); + + final byte rareMap = this.rareMap(); + if (isBitInBitmap(rareMap, bitpos)) { // inplace value + final int index = index(rareMap, mask, bitpos); + + if (getRareKey(index).equals(key)) { + final Object result = getRareVal(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + bitPartitionSize()); + } + + return Optional.empty(); + } + + @Override + boolean hasNodes() { + return nodeArity() != 0; + } + + @Override + Object getRareVal(final int index) { + return getRareVal(this.getClass(), this, index); + } + + @Override + int rarePayloadArity() { + return Integer.bitCount(Byte.toUnsignedInt(rareMap())); + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final Object key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final byte bitpos = bitpos(mask); + + // TODO: generalize bitmap declaration/if/index assignment in code generator pattern + // check for inplace (rare) value + final byte rareMap = rareMap(); + if (isBitInBitmap(rareMap, bitpos)) { + final int rareIndex = index(rareMap, mask, bitpos); + final Object currentKey = getRareKey(rareIndex); + + if (cmp.compare(currentKey, key) == 0) { + final Object currentVal = getRareVal(rareIndex); + details.updated(EitherIntOrObject.ofObject(currentVal)); + + /* + * Case payload == 2: Create new node with remaining pair. The new node will a) either + * become the new root returned, or b) unwrapped and inlined during returning. + */ + if (this.payloadArity() == 0 && this.rarePayloadArity() == 2 && this.nodeArity() == 0) { + final byte newRawMap = + (shift == 0) ? (byte) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf2x0(mutator, newRawMap, newRawMap, getRareKey(1 - rareIndex), + getRareVal(1 - rareIndex)); + } else if (this.payloadArity() == 1 && this.rarePayloadArity() == 1 + && this.nodeArity() == 0) { + final byte newRawMap = + (shift == 0) ? (byte) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf0x1(mutator, (byte) (0), newRawMap, getKey(0), getVal(0)); + } else { + return copyAndRemoveRareValue(mutator, bitpos); + } + } else { + return this; + } + } + + // check for node (not value) + final byte nodeMap = nodeMap(); + if (isBitInBitmap(nodeMap, bitpos)) { + final int nodeIndex = index(nodeMap, mask, bitpos); + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + bitPartitionSize(), details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + if (payloadArity() == 1) { + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToRareInline(mutator, bitpos, subNodeNew); + } + + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + + // no value + return this; + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final byte bitpos = bitpos(mask); + + // TODO: generalize bitmap declaration/if/index assignment in code generator pattern + // check for inplace value + final byte dataMap = dataMap(); + if (isBitInBitmap(dataMap, bitpos)) { + final int dataIndex = index(dataMap, mask, bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + final int currentVal = getVal(dataIndex); + details.updated(EitherIntOrObject.ofInt(currentVal)); + + /* + * Case payload == 2: Create new node with remaining pair. The new node will a) either + * become the new root returned, or b) unwrapped and inlined during returning. + */ + if (this.payloadArity() == 2 && this.rarePayloadArity() == 0 && this.nodeArity() == 0) { + final byte newRawMap = + (shift == 0) ? (byte) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf0x1(mutator, newRawMap, newRawMap, getKey(1 - dataIndex), + getVal(1 - dataIndex)); + } else if (this.payloadArity() == 1 && this.rarePayloadArity() == 1 + && this.nodeArity() == 0) { + final byte newRawMap = + (shift == 0) ? (byte) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf2x0(mutator, (byte) (0), newRawMap, getRareKey(0), getRareVal(0)); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } + + // check for node (not value) + final byte nodeMap = nodeMap(); + if (isBitInBitmap(nodeMap, bitpos)) { + final int nodeIndex = index(nodeMap, mask, bitpos); + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + bitPartitionSize(), details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + if (payloadArity() == 1) { + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToRareInline(mutator, bitpos, subNodeNew); + } + + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + + // no value + return this; + } + + @Override + boolean hasSlots() { + return slotArity() != 0; + } + + @Override + int nodeArity() { + return Integer.bitCount(Byte.toUnsignedInt(nodeMap())); + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final Object key, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final byte bitpos = bitpos(mask); + + // TODO: generalize bitmap declaration/if/index assignment in code generator pattern + // check for inplace (rare) value + final byte rareMap = rareMap(); + if (isBitInBitmap(rareMap, bitpos)) { + final int rareIndex = index(rareMap, mask, bitpos); + final Object currentKey = getRareKey(rareIndex); + + if (currentKey.equals(key)) { + final Object currentVal = getRareVal(rareIndex); + details.updated(EitherIntOrObject.ofObject(currentVal)); + + /* + * Case payload == 2: Create new node with remaining pair. The new node will a) either + * become the new root returned, or b) unwrapped and inlined during returning. + */ + if (this.payloadArity() == 0 && this.rarePayloadArity() == 2 && this.nodeArity() == 0) { + final byte newRawMap = + (shift == 0) ? (byte) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf2x0(mutator, newRawMap, newRawMap, getRareKey(1 - rareIndex), + getRareVal(1 - rareIndex)); + } else if (this.payloadArity() == 1 && this.rarePayloadArity() == 1 + && this.nodeArity() == 0) { + final byte newRawMap = + (shift == 0) ? (byte) (rawMap2() ^ bitpos) : bitpos(mask(keyHash, 0)); + + return nodeOf0x1(mutator, (byte) (0), newRawMap, getKey(0), getVal(0)); + } else { + return copyAndRemoveRareValue(mutator, bitpos); + } + } else { + return this; + } + } + + // check for node (not value) + final byte nodeMap = nodeMap(); + if (isBitInBitmap(nodeMap, bitpos)) { + final int nodeIndex = index(nodeMap, mask, bitpos); + final AbstractMapNode subNode = getNode(nodeIndex); + final AbstractMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + bitPartitionSize(), details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + if (payloadArity() == 1) { + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToRareInline(mutator, bitpos, subNodeNew); + } + + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + + // no value + return this; + } + + @Override + int slotArity() { + return unsafe.getInt(this.getClass(), globalSlotArityOffset); + } + + @Override + public boolean equals(final Object other) { + return equals(this, other); + } + + @Override + int getVal(final int index) { + return getVal(this.getClass(), this, index); + } + + @Override + AbstractMapNode getNode(final int index) { + return getNode(this.getClass(), this, index); + } + } + + private static class HashCollisionMapNode_Heterogeneous_BleedingEdge extends AbstractMapNode { + + final int hash; + final Object[] keys; + final Object[] vals; + + private HashCollisionMapNode_Heterogeneous_BleedingEdge(final int hash, final Object[] keys, + final Object[] vals) { + this.hash = hash; + this.keys = keys; + this.vals = vals; + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final Object currentVal = vals[idx]; + + if (cmp.compare(currentVal, val) == 0) { + return this; + } else { + // add new mapping + final Object[] src = this.vals; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final AbstractMapNode thisNew = + new HashCollisionMapNode_Heterogeneous_BleedingEdge(this.hash, this.keys, dst); + + details.updated(EitherIntOrObject.ofObject(currentVal)); + return thisNew; + } + } + } + + final Object[] keysNew = (Object[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final Object[] valsNew = (Object[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_Heterogeneous_BleedingEdge(keyHash, keysNew, valsNew); + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final Object currentVal = vals[idx]; + + if (currentVal.equals(val)) { + return this; + } else { + // add new mapping + final Object[] src = this.vals; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final AbstractMapNode thisNew = + new HashCollisionMapNode_Heterogeneous_BleedingEdge(this.hash, this.keys, dst); + + details.updated(EitherIntOrObject.ofObject(currentVal)); + return thisNew; + } + } + } + + final Object[] keysNew = (Object[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final Object[] valsNew = (Object[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_Heterogeneous_BleedingEdge(keyHash, keysNew, valsNew); + } + + @Override + Map.Entry getKeyValueEntry(final int index) { + return entryOf(keys[index], vals[index]); + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final Object key, + final Object val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final Object currentVal = vals[idx]; + + if (cmp.compare(currentVal, val) == 0) { + return this; + } else { + // add new mapping + final Object[] src = this.vals; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final AbstractMapNode thisNew = + new HashCollisionMapNode_Heterogeneous_BleedingEdge(this.hash, this.keys, dst); + + details.updated(EitherIntOrObject.ofObject(currentVal)); + return thisNew; + } + } + } + + final Object[] keysNew = (Object[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final Object[] valsNew = (Object[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_Heterogeneous_BleedingEdge(keyHash, keysNew, valsNew); + } + + @Override + AbstractMapNode updated(final AtomicReference mutator, final Object key, + final Object val, final int keyHash, final int shift, final MapResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final Object currentVal = vals[idx]; + + if (currentVal.equals(val)) { + return this; + } else { + // add new mapping + final Object[] src = this.vals; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final AbstractMapNode thisNew = + new HashCollisionMapNode_Heterogeneous_BleedingEdge(this.hash, this.keys, dst); + + details.updated(EitherIntOrObject.ofObject(currentVal)); + return thisNew; + } + } + } + + final Object[] keysNew = (Object[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final Object[] valsNew = (Object[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_Heterogeneous_BleedingEdge(keyHash, keysNew, valsNew); + } + + @Override + Optional findByKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final Object _key = keys[i]; + if (cmp.compare(_key, key) == 0) { + final Object val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + int getKey(final int index) { + throw new IllegalStateException("Converted to `rarePayload`."); + } + + @Override + public String toString() { + throw new UnsupportedOperationException("Not yet implemented."); + } + + @Override + Object getRareKey(final int index) { + return keys[index]; + } + + @Override + boolean containsKeyEquivalent(final Object key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (Object k : keys) { + if (cmp.compare(k, key) == 0) { + return true; + } + } + } + return false; + } + + @Override + boolean containsKey(final int key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (Object k : keys) { + if (k.equals(key)) { + return true; + } + } + } + return false; + } + + @Override + int untypedSlotArity() { + throw new UnsupportedOperationException(); + } + + @Override + Optional findByKey(final Object key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final Object _key = keys[i]; + if (cmp.compare(_key, key) == 0) { + final Object val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + Optional findByKey(final int key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final Object _key = keys[i]; + if (_key.equals(key)) { + final Object val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + int payloadArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final Object currentVal = vals[idx]; + details.updated(EitherIntOrObject.ofObject(currentVal)); + + if (this.arity() == 1) { + return EMPTY_NODE; + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final Object theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final Object theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return EMPTY_NODE.updated(mutator, theOtherKey, theOtherVal, keyHash, 0, details, cmp); + } else { + final Object[] keysNew = (Object[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final Object[] valsNew = (Object[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_Heterogeneous_BleedingEdge(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + @Override + Optional findByKey(final Object key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final Object _key = keys[i]; + if (_key.equals(key)) { + final Object val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final Object key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final Object currentVal = vals[idx]; + details.updated(EitherIntOrObject.ofObject(currentVal)); + + if (this.arity() == 1) { + return EMPTY_NODE; + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final Object theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final Object theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return EMPTY_NODE.updated(mutator, theOtherKey, theOtherVal, keyHash, 0, details, cmp); + } else { + final Object[] keysNew = (Object[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final Object[] valsNew = (Object[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_Heterogeneous_BleedingEdge(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final Object currentVal = vals[idx]; + details.updated(EitherIntOrObject.ofObject(currentVal)); + + if (this.arity() == 1) { + return EMPTY_NODE; + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final Object theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final Object theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return EMPTY_NODE.updated(mutator, theOtherKey, theOtherVal, keyHash, 0, details); + } else { + final Object[] keysNew = (Object[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final Object[] valsNew = (Object[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_Heterogeneous_BleedingEdge(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int nodeArity() { + return 0; + } + + @Override + public AbstractMapNode removed(final AtomicReference mutator, final Object key, + final int keyHash, final int shift, final MapResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final Object currentVal = vals[idx]; + details.updated(EitherIntOrObject.ofObject(currentVal)); + + if (this.arity() == 1) { + return EMPTY_NODE; + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final Object theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final Object theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return EMPTY_NODE.updated(mutator, theOtherKey, theOtherVal, keyHash, 0, details); + } else { + final Object[] keysNew = (Object[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final Object[] valsNew = (Object[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_Heterogeneous_BleedingEdge(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + HashCollisionMapNode_Heterogeneous_BleedingEdge that = + (HashCollisionMapNode_Heterogeneous_BleedingEdge) other; + + if (hash != that.hash) { + return false; + } + + if (arity() != that.arity()) { + return false; + } + + /* + * Linear scan for each key, because of arbitrary element order. + */ + outerLoop: + for (int i = 0; i < that.payloadArity(); i++) { + final Object otherKey = that.getKey(i); + final Object otherVal = that.getVal(i); + + for (int j = 0; j < keys.length; j++) { + final Object key = keys[j]; + final Object val = vals[j]; + + if (key.equals(otherKey) && val.equals(otherVal)) { + continue outerLoop; + } + } + return false; + } + + return true; + } + + @Override + boolean containsKeyEquivalent(final int key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (Object k : keys) { + if (cmp.compare(k, key) == 0) { + return true; + } + } + } + return false; + } + + @Override + boolean containsKey(final Object key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (Object k : keys) { + if (k.equals(key)) { + return true; + } + } + } + return false; + } + + @Override + byte sizePredicate() { + return sizeMoreThanOne(); + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + Object getRareVal(final int index) { + return vals[index]; + } + + @Override + int rarePayloadArity() { + return keys.length; + } + + @Override + AbstractMapNode getNode(final int index) { + throw new IllegalStateException("Is leaf node."); + } + + @Override + int getVal(final int index) { + throw new IllegalStateException("Converted to `rarePayload`."); + } + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractMapIterator { + + private static final int MAX_DEPTH = 11; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractMapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractMapNode[] nodes = new AbstractMapNode[MAX_DEPTH]; + + AbstractMapIterator(AbstractMapNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractMapNode nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class MapKeyIterator extends AbstractMapIterator implements Iterator { + + MapKeyIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public Object next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + protected static class MapValueIterator extends AbstractMapIterator implements Iterator { + + MapValueIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public Object next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getVal(currentValueCursor++); + } + } + + } + + protected static class MapEntryIterator extends AbstractMapIterator + implements Iterator> { + + MapEntryIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKeyValueEntry(currentValueCursor++); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieMap_Heterogeneous_BleedingEdgeNodeIterator + implements Iterator { + + final Deque> nodeIteratorStack; + + TrieMap_Heterogeneous_BleedingEdgeNodeIterator(AbstractMapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractMapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieMap_Heterogeneous_BleedingEdge + implements io.usethesource.capsule.Map.Transient { + + final private AtomicReference mutator; + private AbstractMapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieMap_Heterogeneous_BleedingEdge( + TrieMap_Heterogeneous_BleedingEdge trieMap_Heterogeneous_BleedingEdge) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieMap_Heterogeneous_BleedingEdge.rootNode; + this.hashCode = trieMap_Heterogeneous_BleedingEdge.hashCode; + this.cachedSize = trieMap_Heterogeneous_BleedingEdge.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final Object key = entry.getKey(); + final Object val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public Object put(final Object key, final Object val) { + throw new UnsupportedOperationException(); + } + + @Override + public void putAll(final Map m) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public Object remove(final Object key) { + throw new UnsupportedOperationException(); + } + + public boolean containsKey(final int key) { + return rootNode.containsKey(key, transformHashCode(key), 0); + } + + public boolean containsKeyEquivalent(final int key, final Comparator cmp) { + return rootNode.containsKeyEquivalent(key, transformHashCode(key), 0, cmp); + } + + @Override + public boolean containsKey(final Object o) { + try { + final Object key = (Object) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + final Object key = (Object) o; + return rootNode.containsKeyEquivalent(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + @Override + public Object get(final Object o) { + try { + final int key = (int) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public Object getEquivalent(final Object o, final Comparator cmp) { + try { + final int key = (int) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public Object __put(final int key, final int val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int replacedValue = details.getReplacedValue().getInt(); + + final int valHashOld = replacedValue; + final int valHashNew = val; + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return replacedValue; + } else { + final int valHashNew = (int) val; + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + public Object __putEquivalent(final int key, final int val, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int replacedValue = details.getReplacedValue().getInt(); + + final int valHashOld = replacedValue; + final int valHashNew = val; + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return replacedValue; + } else { + final int valHashNew = (int) val; + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + @Override + public Object __put(final Object key, final Object val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final Object replacedValue = details.getReplacedValue().getObject(); + + final int valHashOld = replacedValue.hashCode(); + final int valHashNew = val.hashCode(); + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return replacedValue; + } else { + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + @Override + public Object __putEquivalent(final Object key, final Object val, + final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final Object replacedValue = details.getReplacedValue().getObject(); + + final int valHashOld = replacedValue.hashCode(); + final int valHashNew = val.hashCode(); + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return replacedValue; + } else { + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + @Override + public boolean __putAll(final Map map) { + boolean modified = false; + + for (Map.Entry entry : map.entrySet()) { + final boolean isPresent = this.containsKey(entry.getKey()); + final Object replaced = this.__put(entry.getKey(), entry.getValue()); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + @Override + public boolean __putAllEquivalent(final Map map, + final Comparator cmp) { + boolean modified = false; + + for (Map.Entry entry : map.entrySet()) { + final boolean isPresent = this.containsKeyEquivalent(entry.getKey(), cmp); + final Object replaced = this.__putEquivalent(entry.getKey(), entry.getValue(), cmp); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + public Object __remove(final int key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getInt(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + public Object __removeEquivalent(final int key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = (int) key; + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getInt(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + @Override + public Object __remove(final Object key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getObject().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + @Override + public Object __removeEquivalent(final Object key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final AbstractMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().getObject().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new TransientMapKeyIterator(this); + } + + @Override + public Iterator valueIterator() { + return new TransientMapValueIterator(this); + } + + @Override + public Iterator> entryIterator() { + return new TransientMapEntryIterator(this); + } + + public static class TransientMapKeyIterator extends MapKeyIterator { + + final TransientTrieMap_Heterogeneous_BleedingEdge collection; + Object lastKey; + + public TransientMapKeyIterator(final TransientTrieMap_Heterogeneous_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public Object next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(lastKey); + } + } + + public static class TransientMapValueIterator extends MapValueIterator { + + final TransientTrieMap_Heterogeneous_BleedingEdge collection; + + public TransientMapValueIterator( + final TransientTrieMap_Heterogeneous_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public Object next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientMapEntryIterator extends MapEntryIterator { + + final TransientTrieMap_Heterogeneous_BleedingEdge collection; + + public TransientMapEntryIterator( + final TransientTrieMap_Heterogeneous_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public Map.Entry next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieMap_Heterogeneous_BleedingEdge.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieMap_Heterogeneous_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_Heterogeneous_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_Heterogeneous_BleedingEdge.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_Heterogeneous_BleedingEdge.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieMap_Heterogeneous_BleedingEdge.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieMap_Heterogeneous_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_Heterogeneous_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_Heterogeneous_BleedingEdge.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieMap_Heterogeneous_BleedingEdge.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieMap_Heterogeneous_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_Heterogeneous_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_Heterogeneous_BleedingEdge.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_Heterogeneous_BleedingEdge.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieMap_Heterogeneous_BleedingEdge) { + TransientTrieMap_Heterogeneous_BleedingEdge that = + (TransientTrieMap_Heterogeneous_BleedingEdge) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final Object key = (Object) entry.getKey(); + final Optional result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + final Object val = (Object) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public io.usethesource.capsule.Map.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieMap_Heterogeneous_BleedingEdge(rootNode, hashCode, cachedSize); + } + } + + private abstract static class DataLayoutHelper extends CompactMapNode { + + private static final long[] arrayOffsets = + arrayOffsets(DataLayoutHelper.class, new String[]{"slot0", "slot1"}); + + public final Object slot0 = null; + + public final Object slot1 = null; + + private DataLayoutHelper() { + super(null, (byte) 0, (byte) 0); + } + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/heterogeneous/TrieMap_Heterogeneous_BleedingEdge_Specializations.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/heterogeneous/TrieMap_Heterogeneous_BleedingEdge_Specializations.java new file mode 100644 index 0000000..4ce831f --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/heterogeneous/TrieMap_Heterogeneous_BleedingEdge_Specializations.java @@ -0,0 +1,3435 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.heterogeneous; + +import java.util.concurrent.atomic.AtomicReference; + +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_Heterogeneous_BleedingEdge.CompactMapNode; + +public class TrieMap_Heterogeneous_BleedingEdge_Specializations { + + protected static class Map0To3Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map0To3Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map3To0Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + + protected Map3To0Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + } + } + + protected static class Map0To1Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final Object slot0; + + protected Map0To1Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + } + } + + protected static class Map1To9Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map1To9Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map2To8Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map2To8Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map2To5Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map2To5Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map1To11Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map1To11Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map4To3Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map4To3Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map1To4Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map1To4Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map5To4Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map5To4Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map2To7Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map2To7Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map0To2Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final Object slot0; + private final Object slot1; + + protected Map0To2Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map8To0Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 16 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + + protected Map8To0Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + } + } + + protected static class Map2To10Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map2To10Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map0To9Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map0To9Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map4To1Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + + protected Map4To1Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + } + } + + protected static class Map5To6Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map5To6Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map1To6Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map1To6Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map3To6Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map3To6Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map4To7Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map4To7Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map2To3Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map2To3Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map4To8Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map4To8Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map0To14Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map0To14Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map6To1Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + + protected Map6To1Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + } + } + + protected static class Map4To5Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map4To5Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map0To13Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map0To13Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map3To4Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map3To4Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map2To1Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + + protected Map2To1Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + } + } + + protected static class Map6To3Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map6To3Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map1To12Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map1To12Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map4To2Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + + protected Map4To2Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map0To5Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map0To5Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map0To8Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map0To8Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map7To0Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + + protected Map7To0Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + } + } + + protected static class Map0To7Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map0To7Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map1To0Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + + protected Map1To0Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + } + } + + protected static class Map5To0Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + + protected Map5To0Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + } + } + + protected static class Map2To2Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + + protected Map2To2Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map2To9Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map2To9Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map0To10Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map0To10Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map6To2Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + + protected Map6To2Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map0To16Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 16; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected Map0To16Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14, final Object slot15) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class Map6To4Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map6To4Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map2To6Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map2To6Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map3To3Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map3To3Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map1To10Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map1To10Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map1To7Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map1To7Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map2To4Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map2To4Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map0To0Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + protected Map0To0Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap) { + super(mutator, nodeMap, dataMap); + + } + } + + protected static class Map3To1Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + + protected Map3To1Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + } + } + + protected static class Map2To11Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map2To11Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map5To5Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map5To5Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map1To8Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map1To8Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map1To5Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map1To5Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map3To5Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 5; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected Map3To5Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class Map3To8Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 8; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected Map3To8Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class Map0To15Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 15; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected Map0To15Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11, final Object slot12, final Object slot13, + final Object slot14) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class Map1To1Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + + protected Map1To1Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, + final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + } + } + + protected static class Map5To1Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + + protected Map5To1Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + } + } + + protected static class Map3To7Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 7; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected Map3To7Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class Map7To1Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 1; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + + protected Map7To1Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + } + } + + protected static class Map4To6Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map4To6Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map1To3Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map1To3Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map5To3Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 3; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected Map5To3Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1, + final Object slot2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class Map3To10Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 10; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected Map3To10Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class Map4To4Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map4To4Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map0To12Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map0To12Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10, final Object slot11) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map3To2Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + + protected Map3To2Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map1To13Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 13; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected Map1To13Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class Map1To14Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 14; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected Map1To14Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class Map3To9Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 9; + + static final long rareBase = arrayBase + 6 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected Map3To9Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class Map4To0Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 8 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + + protected Map4To0Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + } + } + + protected static class Map2To12Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 12; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected Map2To12Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class Map6To0Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 12 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + + protected Map6To0Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + } + } + + protected static class Map0To6Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 6; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected Map0To6Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class Map5To2Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 10 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final Object slot0; + private final Object slot1; + + protected Map5To2Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map1To2Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 2 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final Object slot0; + private final Object slot1; + + protected Map1To2Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final Object slot0, + final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class Map2To0Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 0; + + static final long rareBase = arrayBase + 4 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + + protected Map2To0Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + } + } + + protected static class Map0To4Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 4; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected Map0To4Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class Map0To11Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 11; + + static final long rareBase = arrayBase + 0 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected Map0To11Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final Object slot0, final Object slot1, + final Object slot2, final Object slot3, final Object slot4, final Object slot5, + final Object slot6, final Object slot7, final Object slot8, final Object slot9, + final Object slot10) { + super(mutator, nodeMap, dataMap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class Map7To2Node_Heterogeneous_BleedingEdge extends CompactMapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 2; + + static final long rareBase = arrayBase + 14 * 4 /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final Object slot0; + private final Object slot1; + + protected Map7To2Node_Heterogeneous_BleedingEdge(final AtomicReference mutator, + final byte nodeMap, final byte dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final Object slot0, final Object slot1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/lazy/TrieMap_5Bits_LazyHashCode.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/lazy/TrieMap_5Bits_LazyHashCode.java new file mode 100644 index 0000000..e899d17 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/lazy/TrieMap_5Bits_LazyHashCode.java @@ -0,0 +1,2754 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.lazy; + +import java.text.DecimalFormat; +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Set; +import java.util.concurrent.atomic.AtomicReference; + +import io.usethesource.capsule.util.ArrayUtils; + +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +@SuppressWarnings("rawtypes") +public class TrieMap_5Bits_LazyHashCode implements io.usethesource.capsule.Map.Immutable { + + @SuppressWarnings("unchecked") + private static final TrieMap_5Bits_LazyHashCode EMPTY_MAP = + new TrieMap_5Bits_LazyHashCode(CompactMapNode.EMPTY_NODE, 0); + + private static final boolean DEBUG = false; + + private final AbstractMapNode rootNode; + private int hashCode = -1; + private final int cachedSize; + + TrieMap_5Bits_LazyHashCode(AbstractMapNode rootNode, int cachedSize) { + this.rootNode = rootNode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + @SuppressWarnings("unchecked") + public static final io.usethesource.capsule.Map.Immutable of() { + return TrieMap_5Bits_LazyHashCode.EMPTY_MAP; + } + + @SuppressWarnings("unchecked") + public static final io.usethesource.capsule.Map.Immutable of(Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + io.usethesource.capsule.Map.Immutable result = TrieMap_5Bits_LazyHashCode.EMPTY_MAP; + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final K key = (K) keyValuePairs[i]; + final V val = (V) keyValuePairs[i + 1]; + + result = result.__put(key, val); + } + + return result; + } + + @SuppressWarnings("unchecked") + public static final io.usethesource.capsule.Map.Transient transientOf() { + return TrieMap_5Bits_LazyHashCode.EMPTY_MAP.asTransient(); + } + + @SuppressWarnings("unchecked") + public static final io.usethesource.capsule.Map.Transient transientOf(Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + final io.usethesource.capsule.Map.Transient result = TrieMap_5Bits_LazyHashCode.EMPTY_MAP.asTransient(); + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final K key = (K) keyValuePairs[i]; + final V val = (V) keyValuePairs[i + 1]; + + result.__put(key, val); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext();) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean containsKey(final Object o) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + return rootNode.containsKey(key, key.hashCode(), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + return rootNode.containsKey(key, key.hashCode(), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + @Override + public V get(final Object o) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + final Optional result = rootNode.findByKey(key, key.hashCode(), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public V getEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + final Optional result = rootNode.findByKey(key, key.hashCode(), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public io.usethesource.capsule.Map.Immutable __put(final K key, final V val) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = rootNode.updated(null, key, val, keyHash, 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + return new TrieMap_5Bits_LazyHashCode(newRootNode, cachedSize); + } + + return new TrieMap_5Bits_LazyHashCode(newRootNode, cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __putEquivalent(final K key, final V val, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(null, key, val, keyHash, 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + return new TrieMap_5Bits_LazyHashCode(newRootNode, cachedSize); + } + + return new TrieMap_5Bits_LazyHashCode(newRootNode, cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __putAll(final Map map) { + final io.usethesource.capsule.Map.Transient tmpTransient = this.asTransient(); + tmpTransient.__putAll(map); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Map.Immutable __putAllEquivalent(final Map map, + final Comparator cmp) { + final io.usethesource.capsule.Map.Transient tmpTransient = this.asTransient(); + tmpTransient.__putAllEquivalent(map, cmp); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Map.Immutable __remove(final K key) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = rootNode.removed(null, key, keyHash, 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + return new TrieMap_5Bits_LazyHashCode(newRootNode, cachedSize - 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __removeEquivalent(final K key, final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = rootNode.removed(null, key, keyHash, 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + return new TrieMap_5Bits_LazyHashCode(newRootNode, cachedSize - 1); + } + + return this; + } + + @Override + public V put(final K key, final V val) { + throw new UnsupportedOperationException(); + } + + @Override + public void putAll(final Map m) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public V remove(final Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new MapKeyIterator<>(rootNode); + } + + @Override + public Iterator valueIterator() { + return new MapValueIterator<>(rootNode); + } + + @Override + public Iterator> entryIterator() { + return new MapEntryIterator<>(rootNode); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_LazyHashCode.this.keyIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_LazyHashCode.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_LazyHashCode.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_LazyHashCode.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_LazyHashCode.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_LazyHashCode.this.valueIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_LazyHashCode.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_LazyHashCode.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_LazyHashCode.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TrieMap_5Bits_LazyHashCode.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieMap_5Bits_LazyHashCode.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_LazyHashCode.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_LazyHashCode.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_LazyHashCode.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieMap_5Bits_LazyHashCode) { + TrieMap_5Bits_LazyHashCode that = (TrieMap_5Bits_LazyHashCode) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) { + return false; + } + + for (@SuppressWarnings("unchecked") + Iterator it = that.entrySet().iterator(); it.hasNext();) { + Map.Entry entry = it.next(); + + try { + @SuppressWarnings("unchecked") + final K key = (K) entry.getKey(); + final Optional result = rootNode.findByKey(key, key.hashCode(), 0); + + if (!result.isPresent()) { + return false; + } else { + @SuppressWarnings("unchecked") + final V val = (V) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + if (hashCode == -1) { + int hash = 0; + for (Iterator> it = entryIterator(); it.hasNext();) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + } + hashCode = hash; + } + + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public io.usethesource.capsule.Map.Transient asTransient() { + return new TransientTrieMap_5Bits(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractMapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieMap_5BitsNodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. Payload X Node + */ + protected int[][] arityCombinationsHistogram() { + final Iterator> it = nodeIterator(); + final int[][] sumArityCombinations = new int[33][33]; + + while (it.hasNext()) { + final AbstractMapNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[33]; + + final int maxArity = 32; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[33]; + for (int cumsum = 0, i = 0; i < 33; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 33; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + abstract static class Optional { + private static final Optional EMPTY = new Optional() { + @Override + boolean isPresent() { + return false; + } + + @Override + Object get() { + return null; + } + }; + + @SuppressWarnings("unchecked") + static Optional empty() { + return EMPTY; + } + + static Optional of(T value) { + return new Value(value); + } + + abstract boolean isPresent(); + + abstract T get(); + + private static final class Value extends Optional { + private final T value; + + private Value(T value) { + this.value = value; + } + + @Override + boolean isPresent() { + return true; + } + + @Override + T get() { + return value; + } + } + } + + static final class MapResult { + private V replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(V replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static MapResult unchanged() { + return new MapResult<>(); + } + + private MapResult() {} + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public V getReplacedValue() { + return replacedValue; + } + } + + protected static interface INode { + } + + protected static abstract class AbstractMapNode implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final K key, final int keyHash, final int shift); + + abstract boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final K key, final int keyHash, final int shift); + + abstract Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract CompactMapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + abstract CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractMapNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractMapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractMapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract K getKey(final int index); + + abstract V getValue(final int index); + + abstract Map.Entry getKeyValueEntry(final int index); + + @Deprecated + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + int size() { + final Iterator it = new MapKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactMapNode extends AbstractMapNode { + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + abstract int nodeMap(); + + abstract int dataMap(); + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactMapNode getNode(final int index); + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactMapNode copyAndSetValue(final AtomicReference mutator, + final int bitpos, final V val); + + abstract CompactMapNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final K key, final V val); + + abstract CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos); + + abstract CompactMapNode copyAndSetNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromInlineToNode( + final AtomicReference mutator, final int bitpos, final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromNodeToInline( + final AtomicReference mutator, final int bitpos, final CompactMapNode node); + + @SuppressWarnings("unchecked") + static final CompactMapNode mergeTwoKeyValPairs(final K key0, final V val0, + final int keyHash0, final K key1, final V val1, final int keyHash1, final int shift) { + assert !(key0.equals(key1)); + + if (shift >= HASH_CODE_LENGTH) { + // throw new + // IllegalStateException("Hash collision not yet fixed."); + return new HashCollisionMapNode_5Bits<>(keyHash0, (K[]) new Object[] {key0, key1}, + (V[]) new Object[] {val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int dataMap = bitpos(mask0) | bitpos(mask1); + + if (mask0 < mask1) { + return nodeOf(null, (0), dataMap, new Object[] {key0, val0, key1, val1}); + } else { + return nodeOf(null, (0), dataMap, new Object[] {key1, val1, key0, val0}); + } + } else { + final CompactMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, + keyHash1, shift + BIT_PARTITION_SIZE); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf(null, nodeMap, (0), new Object[] {node}); + } + } + + static final CompactMapNode EMPTY_NODE; + + static { + + EMPTY_NODE = new BitmapIndexedMapNode<>(null, (0), (0), new Object[] {}); + + }; + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object[] nodes) { + return new BitmapIndexedMapNode<>(mutator, nodeMap, dataMap, nodes); + } + + @SuppressWarnings("unchecked") + static final CompactMapNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactMapNode nodeOf(AtomicReference mutator, + final int nodeMap, final int dataMap, final K key, final V val) { + assert nodeMap == 0; + return nodeOf(mutator, (0), dataMap, new Object[] {key, val}); + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + CompactMapNode nodeAt(final int bitpos) { + return getNode(nodeIndex(bitpos)); + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index).equals(key); + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return false; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return cmp.compare(getKey(index), key) == 0; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index).equals(key)) { + final V result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (cmp.compare(getKey(index), key) == 0) { + final V result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return Optional.empty(); + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (currentKey.equals(key)) { + final V currentVal = getValue(dataIndex); + + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } else { + final V currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + currentKey.hashCode(), key, val, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (cmp.compare(currentKey, key) == 0) { + final V currentVal = getValue(dataIndex); + + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } else { + final V currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + currentKey.hashCode(), key, val, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex).equals(key)) { + final V currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(1), getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(0), getValue(0)); + } + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (this.payloadArity() == 0 && this.nodeArity() == 1) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (cmp.compare(getKey(dataIndex), key) == 0) { + final V currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(1), getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(0), getValue(0)); + } + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (this.payloadArity() == 0 && this.nodeArity() == 1) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getKey(i), getValue(i))); + + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedMapNode extends CompactMapNode { + + private final int nodeMap; + private final int dataMap; + + CompactMixedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + private static final class BitmapIndexedMapNode extends CompactMixedMapNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + super(mutator, nodeMap, dataMap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + + assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < TUPLE_LENGTH * payloadArity(); i++) { + assert ((nodes[i] instanceof CompactMapNode) == false); + } + for (int i = TUPLE_LENGTH * payloadArity(); i < nodes.length; i++) { + assert ((nodes[i] instanceof CompactMapNode) == true); + } + } + + assert nodeInvariant(); + } + + @SuppressWarnings("unchecked") + @Override + K getKey(final int index) { + return (K) nodes[TUPLE_LENGTH * index]; + } + + @SuppressWarnings("unchecked") + @Override + V getValue(final int index) { + return (V) nodes[TUPLE_LENGTH * index + 1]; + } + + @Override + @SuppressWarnings("unchecked") + Map.Entry getKeyValueEntry(final int index) { + return entryOf((K) nodes[TUPLE_LENGTH * index], (V) nodes[TUPLE_LENGTH * index + 1]); + } + + @SuppressWarnings("unchecked") + @Override + CompactMapNode getNode(final int index) { + return (CompactMapNode) nodes[nodes.length - 1 - index]; + } + + @Override + boolean hasPayload() { + return dataMap() != 0; + } + + @Override + int payloadArity() { + return java.lang.Integer.bitCount(dataMap()); + } + + @Override + boolean hasNodes() { + return nodeMap() != 0; + } + + @Override + int nodeArity() { + return java.lang.Integer.bitCount(nodeMap()); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + (nodeMap()); + result = prime * result + (dataMap()); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedMapNode that = (BitmapIndexedMapNode) other; + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + if (!ArrayUtils.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + if (this.nodeArity() == 0) { + switch (this.payloadArity()) { + case 0: + return SIZE_EMPTY; + case 1: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } else { + return SIZE_MORE_THAN_ONE; + } + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos) + 1; + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = val; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(bitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = val; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + return nodeOf(mutator, nodeMap(), dataMap() | bitpos, dst); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + return nodeOf(mutator, nodeMap(), dataMap() ^ bitpos, dst); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2 + 1]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 2, dst, idxNew + 1, src.length - idxNew - 2); + + return nodeOf(mutator, nodeMap() | bitpos, dataMap() ^ bitpos, dst); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 2]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = node.getKey(0); + dst[idxNew + 1] = node.getValue(0); + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 2, src.length - idxOld - 1); + + return nodeOf(mutator, nodeMap() ^ bitpos, dataMap() | bitpos, dst); + } + + } + + private static final class HashCollisionMapNode_5Bits extends CompactMapNode { + private final K[] keys; + private final V[] vals; + private final int hash; + + HashCollisionMapNode_5Bits(final int hash, final K[] keys, final V[] vals) { + this.keys = keys; + this.vals = vals; + this.hash = hash; + + assert payloadArity() >= 2; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (K k : keys) { + if (k.equals(key)) { + return true; + } + } + } + return false; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (K k : keys) { + if (cmp.compare(k, key) == 0) { + return true; + } + } + } + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (key.equals(_key)) { + final V val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (cmp.compare(key, _key) == 0) { + final V val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final V currentVal = vals[idx]; + + if (currentVal.equals(val)) { + return this; + } else { + // add new mapping + final V[] src = this.vals; + @SuppressWarnings("unchecked") + final V[] dst = (V[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode_5Bits<>(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + @SuppressWarnings("unchecked") + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + @SuppressWarnings("unchecked") + final V[] valsNew = (V[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits<>(keyHash, keysNew, valsNew); + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final V currentVal = vals[idx]; + + if (cmp.compare(currentVal, val) == 0) { + return this; + } else { + // add new mapping + final V[] src = this.vals; + @SuppressWarnings("unchecked") + final V[] dst = (V[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode_5Bits<>(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + @SuppressWarnings("unchecked") + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + @SuppressWarnings("unchecked") + final V[] valsNew = (V[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits<>(keyHash, keysNew, valsNew); + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final V currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final V theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details); + } else { + @SuppressWarnings("unchecked") + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + @SuppressWarnings("unchecked") + final V[] valsNew = (V[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits<>(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final V currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final V theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details, cmp); + } else { + @SuppressWarnings("unchecked") + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + @SuppressWarnings("unchecked") + final V[] valsNew = (V[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits<>(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return keys.length; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + int arity() { + return payloadArity(); + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + K getKey(final int index) { + return keys[index]; + } + + @Override + V getValue(final int index) { + return vals[index]; + } + + @Override + Map.Entry getKeyValueEntry(final int index) { + return entryOf(keys[index], vals[index]); + } + + @Override + public CompactMapNode getNode(int index) { + throw new IllegalStateException("Is leaf node."); + } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + hash; + result = prime * result + Arrays.hashCode(keys); + result = prime * result + Arrays.hashCode(vals); + return result; + } + + @Override + public boolean equals(Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + HashCollisionMapNode_5Bits that = (HashCollisionMapNode_5Bits) other; + + if (hash != that.hash) { + return false; + } + + if (arity() != that.arity()) { + return false; + } + + /* + * Linear scan for each key, because of arbitrary element order. + */ + outerLoop: for (int i = 0; i < that.payloadArity(); i++) { + final Object otherKey = that.getKey(i); + final Object otherVal = that.getValue(i); + + for (int j = 0; j < keys.length; j++) { + final K key = keys[j]; + final V val = vals[j]; + + if (key.equals(otherKey) && val.equals(otherVal)) { + continue outerLoop; + } + } + return false; + } + + return true; + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + int nodeMap() { + throw new UnsupportedOperationException(); + } + + @Override + int dataMap() { + throw new UnsupportedOperationException(); + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractMapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractMapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + @SuppressWarnings("unchecked") + AbstractMapNode[] nodes = new AbstractMapNode[MAX_DEPTH]; + + AbstractMapIterator(AbstractMapNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractMapNode nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class MapKeyIterator extends AbstractMapIterator + implements Iterator { + + MapKeyIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + protected static class MapValueIterator extends AbstractMapIterator + implements Iterator { + + MapValueIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public V next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getValue(currentValueCursor++); + } + } + + } + + protected static class MapEntryIterator extends AbstractMapIterator + implements Iterator> { + + MapEntryIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKeyValueEntry(currentValueCursor++); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieMap_5BitsNodeIterator implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieMap_5BitsNodeIterator(AbstractMapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractMapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieMap_5Bits implements io.usethesource.capsule.Map.Transient { + final private AtomicReference mutator; + private AbstractMapNode rootNode; + private int cachedSize; + + TransientTrieMap_5Bits(TrieMap_5Bits_LazyHashCode trieMap_5Bits) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieMap_5Bits.rootNode; + this.cachedSize = trieMap_5Bits.cachedSize; + } + + @Override + public V put(final K key, final V val) { + throw new UnsupportedOperationException(); + } + + @Override + public void putAll(final Map m) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public V remove(final Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean containsKey(final Object o) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + return rootNode.containsKey(key, key.hashCode(), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + return rootNode.containsKey(key, key.hashCode(), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + @Override + public V get(Object o) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + final Optional result = rootNode.findByKey(key, key.hashCode(), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public V getEquivalent(Object o, Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + final Optional result = rootNode.findByKey(key, key.hashCode(), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public V __put(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(mutator, key, val, keyHash, 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + rootNode = newRootNode; + + return details.getReplacedValue(); + } else { + rootNode = newRootNode; + cachedSize += 1; + + return null; + } + } + + return null; + } + + @Override + public V __putEquivalent(final K key, final V val, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(mutator, key, val, keyHash, 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + rootNode = newRootNode; + + return details.getReplacedValue(); + } else { + rootNode = newRootNode; + cachedSize += 1; + + return null; + } + } + + return null; + } + + @Override + public boolean __putAll(final Map map) { + boolean modified = false; + + for (Map.Entry entry : map.entrySet()) { + final boolean isPresent = this.containsKey(entry.getKey()); + final V replaced = this.__put(entry.getKey(), entry.getValue()); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + @Override + public boolean __putAllEquivalent(final Map map, + final Comparator cmp) { + boolean modified = false; + + for (Map.Entry entry : map.entrySet()) { + final boolean isPresent = this.containsKeyEquivalent(entry.getKey(), cmp); + final V replaced = this.__putEquivalent(entry.getKey(), entry.getValue(), cmp); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + @Override + public V __remove(final K key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = rootNode.removed(mutator, key, keyHash, 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + + rootNode = newRootNode; + cachedSize = cachedSize - 1; + + return details.getReplacedValue(); + } + + return null; + } + + @Override + public V __removeEquivalent(final K key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(mutator, key, keyHash, 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + + rootNode = newRootNode; + cachedSize = cachedSize - 1; + + return details.getReplacedValue(); + } + + return null; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new TransientMapKeyIterator<>(this); + } + + @Override + public Iterator valueIterator() { + return new TransientMapValueIterator<>(this); + } + + @Override + public Iterator> entryIterator() { + return new TransientMapEntryIterator<>(this); + } + + public static class TransientMapKeyIterator extends MapKeyIterator { + final TransientTrieMap_5Bits collection; + K lastKey; + + public TransientMapKeyIterator(final TransientTrieMap_5Bits collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(lastKey); + } + } + + public static class TransientMapValueIterator extends MapValueIterator { + final TransientTrieMap_5Bits collection; + + public TransientMapValueIterator(final TransientTrieMap_5Bits collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public V next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientMapEntryIterator extends MapEntryIterator { + final TransientTrieMap_5Bits collection; + + public TransientMapEntryIterator(final TransientTrieMap_5Bits collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public Map.Entry next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieMap_5Bits.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieMap_5Bits.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieMap_5Bits) { + TransientTrieMap_5Bits that = (TransientTrieMap_5Bits) other; + + if (this.size() != that.size()) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) { + return false; + } + + for (@SuppressWarnings("unchecked") + Iterator it = that.entrySet().iterator(); it.hasNext();) { + Map.Entry entry = it.next(); + + try { + @SuppressWarnings("unchecked") + final K key = (K) entry.getKey(); + final Optional result = rootNode.findByKey(key, key.hashCode(), 0); + + if (!result.isPresent()) { + return false; + } else { + @SuppressWarnings("unchecked") + final V val = (V) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + int hash = 0; + for (Iterator> it = entryIterator(); it.hasNext();) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + } + return hash; + } + + @Override + public io.usethesource.capsule.Map.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieMap_5Bits_LazyHashCode(rootNode, cachedSize); + } + } + +} diff --git a/src/main/java/io/usethesource/capsule/TrieSet_5Bits.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/lazy/TrieSet_5Bits_LazyHashCode.java similarity index 89% rename from src/main/java/io/usethesource/capsule/TrieSet_5Bits.java rename to capsule-experimental/src/main/java/io/usethesource/capsule/experimental/lazy/TrieSet_5Bits_LazyHashCode.java index bd0f97d..73f3d38 100644 --- a/src/main/java/io/usethesource/capsule/TrieSet_5Bits.java +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/lazy/TrieSet_5Bits_LazyHashCode.java @@ -5,7 +5,7 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; +package io.usethesource.capsule.experimental.lazy; import java.text.DecimalFormat; import java.util.ArrayDeque; @@ -18,39 +18,37 @@ import java.util.Iterator; import java.util.List; import java.util.NoSuchElementException; -import java.util.Objects; import java.util.Set; import java.util.concurrent.atomic.AtomicReference; +import io.usethesource.capsule.util.ArrayUtils; + @SuppressWarnings("rawtypes") -public class TrieSet_5Bits implements ImmutableSet { +public class TrieSet_5Bits_LazyHashCode implements io.usethesource.capsule.Set.Immutable { @SuppressWarnings("unchecked") - private static final TrieSet_5Bits EMPTY_SET = new TrieSet_5Bits(CompactSetNode.EMPTY_NODE, 0, 0); + private static final TrieSet_5Bits_LazyHashCode EMPTY_SET = + new TrieSet_5Bits_LazyHashCode(CompactSetNode.EMPTY_NODE, 0); private static final boolean DEBUG = false; private final AbstractSetNode rootNode; - private final int hashCode; + private int hashCode = -1; private final int cachedSize; - TrieSet_5Bits(AbstractSetNode rootNode, int hashCode, int cachedSize) { + TrieSet_5Bits_LazyHashCode(AbstractSetNode rootNode, int cachedSize) { this.rootNode = rootNode; - this.hashCode = hashCode; this.cachedSize = cachedSize; - if (DEBUG) { - assert checkHashCodeAndSize(hashCode, cachedSize); - } } @SuppressWarnings("unchecked") - public static final ImmutableSet of() { - return TrieSet_5Bits.EMPTY_SET; + public static final io.usethesource.capsule.Set.Immutable of() { + return TrieSet_5Bits_LazyHashCode.EMPTY_SET; } @SuppressWarnings("unchecked") - public static final ImmutableSet of(K... keys) { - ImmutableSet result = TrieSet_5Bits.EMPTY_SET; + public static final io.usethesource.capsule.Set.Immutable of(K... keys) { + io.usethesource.capsule.Set.Immutable result = TrieSet_5Bits_LazyHashCode.EMPTY_SET; for (final K key : keys) { result = result.__insert(key); @@ -60,13 +58,13 @@ public static final ImmutableSet of(K... keys) { } @SuppressWarnings("unchecked") - public static final TransientSet transientOf() { - return TrieSet_5Bits.EMPTY_SET.asTransient(); + public static final io.usethesource.capsule.Set.Transient transientOf() { + return TrieSet_5Bits_LazyHashCode.EMPTY_SET.asTransient(); } @SuppressWarnings("unchecked") - public static final TransientSet transientOf(K... keys) { - final TransientSet result = TrieSet_5Bits.EMPTY_SET.asTransient(); + public static final io.usethesource.capsule.Set.Transient transientOf(K... keys) { + final io.usethesource.capsule.Set.Transient result = TrieSet_5Bits_LazyHashCode.EMPTY_SET.asTransient(); for (final K key : keys) { result.__insert(key); @@ -75,30 +73,12 @@ public static final TransientSet transientOf(K... keys) { return result; } - private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { - int hash = 0; - int size = 0; - - for (Iterator it = keyIterator(); it.hasNext();) { - final K key = it.next(); - - hash += key.hashCode(); - size += 1; - } - - return hash == targetHash && size == targetSize; - } - - public static final int transformHashCode(final int hash) { - return hash; - } - @Override public boolean contains(final Object o) { try { @SuppressWarnings("unchecked") final K key = (K) o; - return rootNode.contains(key, transformHashCode(key.hashCode()), 0); + return rootNode.contains(key, key.hashCode(), 0); } catch (ClassCastException unused) { return false; } @@ -109,7 +89,7 @@ public boolean containsEquivalent(final Object o, final Comparator cmp) try { @SuppressWarnings("unchecked") final K key = (K) o; - return rootNode.contains(key, transformHashCode(key.hashCode()), 0, cmp); + return rootNode.contains(key, key.hashCode(), 0, cmp); } catch (ClassCastException unused) { return false; } @@ -120,7 +100,7 @@ public K get(final Object o) { try { @SuppressWarnings("unchecked") final K key = (K) o; - final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + final Optional result = rootNode.findByKey(key, key.hashCode(), 0); if (result.isPresent()) { return result.get(); @@ -137,7 +117,7 @@ public K getEquivalent(final Object o, final Comparator cmp) { try { @SuppressWarnings("unchecked") final K key = (K) o; - final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + final Optional result = rootNode.findByKey(key, key.hashCode(), 0, cmp); if (result.isPresent()) { return result.get(); @@ -150,106 +130,102 @@ public K getEquivalent(final Object o, final Comparator cmp) { } @Override - public ImmutableSet __insert(final K key) { + public io.usethesource.capsule.Set.Immutable __insert(final K key) { final int keyHash = key.hashCode(); final SetResult details = SetResult.unchanged(); - final CompactSetNode newRootNode = - rootNode.updated(null, key, transformHashCode(keyHash), 0, details); + final CompactSetNode newRootNode = rootNode.updated(null, key, keyHash, 0, details); if (details.isModified()) { - return new TrieSet_5Bits(newRootNode, hashCode + keyHash, cachedSize + 1); + return new TrieSet_5Bits_LazyHashCode(newRootNode, cachedSize + 1); } return this; } @Override - public ImmutableSet __insertEquivalent(final K key, final Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __insertEquivalent(final K key, final Comparator cmp) { final int keyHash = key.hashCode(); final SetResult details = SetResult.unchanged(); - final CompactSetNode newRootNode = - rootNode.updated(null, key, transformHashCode(keyHash), 0, details, cmp); + final CompactSetNode newRootNode = rootNode.updated(null, key, keyHash, 0, details, cmp); if (details.isModified()) { - return new TrieSet_5Bits(newRootNode, hashCode + keyHash, cachedSize + 1); + return new TrieSet_5Bits_LazyHashCode(newRootNode, cachedSize + 1); } return this; } @Override - public ImmutableSet __insertAll(final Set set) { - final TransientSet tmpTransient = this.asTransient(); + public io.usethesource.capsule.Set.Immutable __insertAll(final Set set) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); tmpTransient.__insertAll(set); return tmpTransient.freeze(); } @Override - public ImmutableSet __insertAllEquivalent(final Set set, - final Comparator cmp) { - final TransientSet tmpTransient = this.asTransient(); + public io.usethesource.capsule.Set.Immutable __insertAllEquivalent(final Set set, + final Comparator cmp) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); tmpTransient.__insertAllEquivalent(set, cmp); return tmpTransient.freeze(); } @Override - public ImmutableSet __remove(final K key) { + public io.usethesource.capsule.Set.Immutable __remove(final K key) { final int keyHash = key.hashCode(); final SetResult details = SetResult.unchanged(); - final CompactSetNode newRootNode = - rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + final CompactSetNode newRootNode = rootNode.removed(null, key, keyHash, 0, details); if (details.isModified()) { - return new TrieSet_5Bits(newRootNode, hashCode - keyHash, cachedSize - 1); + return new TrieSet_5Bits_LazyHashCode(newRootNode, cachedSize - 1); } return this; } @Override - public ImmutableSet __removeEquivalent(final K key, final Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __removeEquivalent(final K key, final Comparator cmp) { final int keyHash = key.hashCode(); final SetResult details = SetResult.unchanged(); - final CompactSetNode newRootNode = - rootNode.removed(null, key, transformHashCode(keyHash), 0, details, cmp); + final CompactSetNode newRootNode = rootNode.removed(null, key, keyHash, 0, details, cmp); if (details.isModified()) { - return new TrieSet_5Bits(newRootNode, hashCode - keyHash, cachedSize - 1); + return new TrieSet_5Bits_LazyHashCode(newRootNode, cachedSize - 1); } return this; } @Override - public ImmutableSet __removeAll(final Set set) { - final TransientSet tmpTransient = this.asTransient(); + public io.usethesource.capsule.Set.Immutable __removeAll(final Set set) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); tmpTransient.__removeAll(set); return tmpTransient.freeze(); } @Override - public ImmutableSet __removeAllEquivalent(final Set set, - final Comparator cmp) { - final TransientSet tmpTransient = this.asTransient(); + public io.usethesource.capsule.Set.Immutable __removeAllEquivalent(final Set set, + final Comparator cmp) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); tmpTransient.__removeAllEquivalent(set, cmp); return tmpTransient.freeze(); } @Override - public ImmutableSet __retainAll(final Set set) { - final TransientSet tmpTransient = this.asTransient(); + public io.usethesource.capsule.Set.Immutable __retainAll(final Set set) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); tmpTransient.__retainAll(set); return tmpTransient.freeze(); } @Override - public ImmutableSet __retainAllEquivalent(final TransientSet transientSet, - final Comparator cmp) { - final TransientSet tmpTransient = this.asTransient(); + public io.usethesource.capsule.Set.Immutable __retainAllEquivalent(final io.usethesource.capsule.Set.Transient transientSet, + final Comparator cmp) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); tmpTransient.__retainAllEquivalent(transientSet, cmp); return tmpTransient.freeze(); } @@ -356,8 +332,8 @@ public boolean equals(final Object other) { return false; } - if (other instanceof TrieSet_5Bits) { - TrieSet_5Bits that = (TrieSet_5Bits) other; + if (other instanceof TrieSet_5Bits_LazyHashCode) { + TrieSet_5Bits_LazyHashCode that = (TrieSet_5Bits_LazyHashCode) other; if (this.cachedSize != that.cachedSize) { return false; @@ -383,6 +359,15 @@ public boolean equals(final Object other) { @Override public int hashCode() { + if (hashCode == -1) { + int hash = 0; + for (Iterator it = keyIterator(); it.hasNext();) { + final K key = it.next(); + hash += key.hashCode(); + } + hashCode = hash; + } + return hashCode; } @@ -392,7 +377,7 @@ public boolean isTransientSupported() { } @Override - public TransientSet asTransient() { + public io.usethesource.capsule.Set.Transient asTransient() { return new TransientTrieSet_5Bits(this); } @@ -747,6 +732,7 @@ abstract CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference< abstract CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, final int bitpos, final CompactSetNode node); + @SuppressWarnings("unchecked") static final CompactSetNode mergeTwoKeyValPairs(final K key0, final int keyHash0, final K key1, final int keyHash1, final int shift) { assert !(key0.equals(key1)); @@ -925,7 +911,7 @@ CompactSetNode updated(final AtomicReference mutator, final K key, fi return this; } else { final CompactSetNode subNodeNew = mergeTwoKeyValPairs(currentKey, - transformHashCode(currentKey.hashCode()), key, keyHash, shift + BIT_PARTITION_SIZE); + currentKey.hashCode(), key, keyHash, shift + BIT_PARTITION_SIZE); details.modified(); return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); @@ -961,7 +947,7 @@ CompactSetNode updated(final AtomicReference mutator, final K key, fi return this; } else { final CompactSetNode subNodeNew = mergeTwoKeyValPairs(currentKey, - transformHashCode(currentKey.hashCode()), key, keyHash, shift + BIT_PARTITION_SIZE); + currentKey.hashCode(), key, keyHash, shift + BIT_PARTITION_SIZE); details.modified(); return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); @@ -1142,7 +1128,7 @@ public String toString() { for (byte i = 0; i < payloadArity(); i++) { final byte pos = recoverMask(dataMap(), (byte) (i + 1)); - bldr.append(String.format("@%d<#%d>", pos, Objects.hashCode(getKey(i)))); + bldr.append(String.format("@%d: ", pos, getKey(i))); if (!((i + 1) == payloadArity())) { bldr.append(", "); @@ -1394,7 +1380,7 @@ CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference m final int bitpos, final CompactSetNode node) { final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); - final int idxNew = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = dataIndex(bitpos); final Object[] src = this.nodes; final Object[] dst = new Object[src.length - 1 + 1]; @@ -1528,7 +1514,6 @@ CompactSetNode removed(final AtomicReference mutator, final K key, fi final int shift, final SetResult details) { for (int idx = 0; idx < keys.length; idx++) { if (keys[idx].equals(key)) { - details.modified(); if (this.arity() == 1) { return nodeOf(mutator); @@ -1562,7 +1547,6 @@ CompactSetNode removed(final AtomicReference mutator, final K key, fi final int shift, final SetResult details, final Comparator cmp) { for (int idx = 0; idx < keys.length; idx++) { if (cmp.compare(keys[idx], key) == 0) { - details.modified(); if (this.arity() == 1) { return nodeOf(mutator); @@ -1895,34 +1879,15 @@ public void remove() { } } - static final class TransientTrieSet_5Bits implements TransientSet { + static final class TransientTrieSet_5Bits implements io.usethesource.capsule.Set.Transient { final private AtomicReference mutator; private AbstractSetNode rootNode; - private int hashCode; private int cachedSize; - TransientTrieSet_5Bits(TrieSet_5Bits trieSet_5Bits) { + TransientTrieSet_5Bits(TrieSet_5Bits_LazyHashCode trieSet_5Bits) { this.mutator = new AtomicReference(Thread.currentThread()); this.rootNode = trieSet_5Bits.rootNode; - this.hashCode = trieSet_5Bits.hashCode; this.cachedSize = trieSet_5Bits.cachedSize; - if (DEBUG) { - assert checkHashCodeAndSize(hashCode, cachedSize); - } - } - - private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { - int hash = 0; - int size = 0; - - for (Iterator it = keyIterator(); it.hasNext();) { - final K key = it.next(); - - hash += key.hashCode(); - size += 1; - } - - return hash == targetHash && size == targetSize; } @Override @@ -1960,7 +1925,7 @@ public boolean contains(final Object o) { try { @SuppressWarnings("unchecked") final K key = (K) o; - return rootNode.contains(key, transformHashCode(key.hashCode()), 0); + return rootNode.contains(key, key.hashCode(), 0); } catch (ClassCastException unused) { return false; } @@ -1971,18 +1936,18 @@ public boolean containsEquivalent(final Object o, final Comparator cmp) try { @SuppressWarnings("unchecked") final K key = (K) o; - return rootNode.contains(key, transformHashCode(key.hashCode()), 0, cmp); + return rootNode.contains(key, key.hashCode(), 0, cmp); } catch (ClassCastException unused) { return false; } } @Override - public K get(final Object o) { + public K get(Object o) { try { @SuppressWarnings("unchecked") final K key = (K) o; - final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + final Optional result = rootNode.findByKey(key, key.hashCode(), 0); if (result.isPresent()) { return result.get(); @@ -1995,12 +1960,11 @@ public K get(final Object o) { } @Override - public K getEquivalent(final Object o, final Comparator cmp) { + public K getEquivalent(Object o, Comparator cmp) { try { @SuppressWarnings("unchecked") final K key = (K) o; - final Optional result = - rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + final Optional result = rootNode.findByKey(key, key.hashCode(), 0, cmp); if (result.isPresent()) { return result.get(); @@ -2021,25 +1985,17 @@ public boolean __insert(final K key) { final int keyHash = key.hashCode(); final SetResult details = SetResult.unchanged(); - final CompactSetNode newRootNode = - rootNode.updated(mutator, key, transformHashCode(keyHash), 0, details); + final CompactSetNode newRootNode = rootNode.updated(mutator, key, keyHash, 0, details); if (details.isModified()) { rootNode = newRootNode; - hashCode += keyHash; cachedSize += 1; - if (DEBUG) { - assert checkHashCodeAndSize(hashCode, cachedSize); - } return true; } - if (DEBUG) { - assert checkHashCodeAndSize(hashCode, cachedSize); - } return false; } @@ -2053,24 +2009,17 @@ public boolean __insertEquivalent(final K key, final Comparator cmp) { final SetResult details = SetResult.unchanged(); final CompactSetNode newRootNode = - rootNode.updated(mutator, key, transformHashCode(keyHash), 0, details, cmp); + rootNode.updated(mutator, key, keyHash, 0, details, cmp); if (details.isModified()) { rootNode = newRootNode; - hashCode += keyHash; cachedSize += 1; - if (DEBUG) { - assert checkHashCodeAndSize(hashCode, cachedSize); - } return true; } - if (DEBUG) { - assert checkHashCodeAndSize(hashCode, cachedSize); - } return false; } @@ -2105,24 +2054,15 @@ public boolean __remove(final K key) { final int keyHash = key.hashCode(); final SetResult details = SetResult.unchanged(); - final CompactSetNode newRootNode = - rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + final CompactSetNode newRootNode = rootNode.removed(mutator, key, keyHash, 0, details); if (details.isModified()) { rootNode = newRootNode; - hashCode = hashCode - keyHash; cachedSize = cachedSize - 1; - if (DEBUG) { - assert checkHashCodeAndSize(hashCode, cachedSize); - } return true; } - if (DEBUG) { - assert checkHashCodeAndSize(hashCode, cachedSize); - } - return false; } @@ -2136,23 +2076,15 @@ public boolean __removeEquivalent(final K key, final Comparator cmp) { final SetResult details = SetResult.unchanged(); final CompactSetNode newRootNode = - rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details, cmp); + rootNode.removed(mutator, key, keyHash, 0, details, cmp); if (details.isModified()) { rootNode = newRootNode; - hashCode = hashCode - keyHash; cachedSize = cachedSize - 1; - if (DEBUG) { - assert checkHashCodeAndSize(hashCode, cachedSize); - } return true; } - if (DEBUG) { - assert checkHashCodeAndSize(hashCode, cachedSize); - } - return false; } @@ -2194,7 +2126,7 @@ public boolean __retainAll(final Set set) { } @Override - public boolean __retainAllEquivalent(final TransientSet transientSet, + public boolean __retainAllEquivalent(final io.usethesource.capsule.Set.Transient transientSet, final Comparator cmp) { boolean modified = false; @@ -2305,11 +2237,7 @@ public boolean equals(final Object other) { if (other instanceof TransientTrieSet_5Bits) { TransientTrieSet_5Bits that = (TransientTrieSet_5Bits) other; - if (this.cachedSize != that.cachedSize) { - return false; - } - - if (this.hashCode != that.hashCode) { + if (this.size() != that.size()) { return false; } @@ -2329,17 +2257,22 @@ public boolean equals(final Object other) { @Override public int hashCode() { - return hashCode; + int hash = 0; + for (Iterator it = keyIterator(); it.hasNext();) { + final K key = it.next(); + hash += key.hashCode(); + } + return hash; } @Override - public ImmutableSet freeze() { + public io.usethesource.capsule.Set.Immutable freeze() { if (mutator.get() == null) { throw new IllegalStateException("Transient already frozen."); } mutator.set(null); - return new TrieSet_5Bits(rootNode, hashCode, cachedSize); + return new TrieSet_5Bits_LazyHashCode(rootNode, cachedSize); } } diff --git a/src/main/java/io/usethesource/capsule/TrieMap_5Bits_Memoized_LazyHashCode.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/memoized/TrieMap_5Bits_Memoized_LazyHashCode.java similarity index 95% rename from src/main/java/io/usethesource/capsule/TrieMap_5Bits_Memoized_LazyHashCode.java rename to capsule-experimental/src/main/java/io/usethesource/capsule/experimental/memoized/TrieMap_5Bits_Memoized_LazyHashCode.java index 957bdc7..54c6d03 100644 --- a/src/main/java/io/usethesource/capsule/TrieMap_5Bits_Memoized_LazyHashCode.java +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/memoized/TrieMap_5Bits_Memoized_LazyHashCode.java @@ -5,9 +5,7 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; - -import static io.usethesource.capsule.AbstractSpecialisedImmutableMap.entryOf; +package io.usethesource.capsule.experimental.memoized; import java.text.DecimalFormat; import java.util.AbstractCollection; @@ -25,10 +23,14 @@ import java.util.Set; import java.util.concurrent.atomic.AtomicReference; -@SuppressWarnings("rawtypes") -public class TrieMap_5Bits_Memoized_LazyHashCode implements ImmutableMap { +import io.usethesource.capsule.util.ArrayUtils; +import io.usethesource.capsule.util.ArrayUtilsInt; + +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +public class TrieMap_5Bits_Memoized_LazyHashCode implements + io.usethesource.capsule.Map.Immutable { - @SuppressWarnings("unchecked") private static final TrieMap_5Bits_Memoized_LazyHashCode EMPTY_MAP = new TrieMap_5Bits_Memoized_LazyHashCode(CompactMapNode.EMPTY_NODE, 0); @@ -46,18 +48,17 @@ public class TrieMap_5Bits_Memoized_LazyHashCode implements ImmutableMap ImmutableMap of() { + public static final io.usethesource.capsule.Map.Immutable of() { return TrieMap_5Bits_Memoized_LazyHashCode.EMPTY_MAP; } - @SuppressWarnings("unchecked") - public static final ImmutableMap of(Object... keyValuePairs) { + public static final io.usethesource.capsule.Map.Immutable of( + Object... keyValuePairs) { if (keyValuePairs.length % 2 != 0) { throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); } - ImmutableMap result = TrieMap_5Bits_Memoized_LazyHashCode.EMPTY_MAP; + io.usethesource.capsule.Map.Immutable result = TrieMap_5Bits_Memoized_LazyHashCode.EMPTY_MAP; for (int i = 0; i < keyValuePairs.length; i += 2) { final K key = (K) keyValuePairs[i]; @@ -69,18 +70,18 @@ public static final ImmutableMap of(Object... keyValuePairs) { return result; } - @SuppressWarnings("unchecked") - public static final TransientMap transientOf() { + public static final io.usethesource.capsule.Map.Transient transientOf() { return TrieMap_5Bits_Memoized_LazyHashCode.EMPTY_MAP.asTransient(); } - @SuppressWarnings("unchecked") - public static final TransientMap transientOf(Object... keyValuePairs) { + public static final io.usethesource.capsule.Map.Transient transientOf( + Object... keyValuePairs) { if (keyValuePairs.length % 2 != 0) { throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); } - final TransientMap result = TrieMap_5Bits_Memoized_LazyHashCode.EMPTY_MAP.asTransient(); + final io.usethesource.capsule.Map.Transient result = TrieMap_5Bits_Memoized_LazyHashCode.EMPTY_MAP + .asTransient(); for (int i = 0; i < keyValuePairs.length; i += 2) { final K key = (K) keyValuePairs[i]; @@ -96,7 +97,7 @@ private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) int hash = 0; int size = 0; - for (Iterator> it = entryIterator(); it.hasNext();) { + for (Iterator> it = entryIterator(); it.hasNext(); ) { final Map.Entry entry = it.next(); final K key = entry.getKey(); final V val = entry.getValue(); @@ -115,7 +116,6 @@ public static final int transformHashCode(final int hash) { @Override public boolean containsKey(final Object o) { try { - @SuppressWarnings("unchecked") final K key = (K) o; return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); } catch (ClassCastException unused) { @@ -126,7 +126,6 @@ public boolean containsKey(final Object o) { @Override public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { try { - @SuppressWarnings("unchecked") final K key = (K) o; return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); } catch (ClassCastException unused) { @@ -136,7 +135,7 @@ public boolean containsKeyEquivalent(final Object o, final Comparator cm @Override public boolean containsValue(final Object o) { - for (Iterator iterator = valueIterator(); iterator.hasNext();) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { if (iterator.next().equals(o)) { return true; } @@ -146,7 +145,7 @@ public boolean containsValue(final Object o) { @Override public boolean containsValueEquivalent(final Object o, final Comparator cmp) { - for (Iterator iterator = valueIterator(); iterator.hasNext();) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { if (cmp.compare(iterator.next(), o) == 0) { return true; } @@ -157,7 +156,6 @@ public boolean containsValueEquivalent(final Object o, final Comparator @Override public V get(final Object o) { try { - @SuppressWarnings("unchecked") final K key = (K) o; final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); @@ -174,7 +172,6 @@ public V get(final Object o) { @Override public V getEquivalent(final Object o, final Comparator cmp) { try { - @SuppressWarnings("unchecked") final K key = (K) o; final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); @@ -189,7 +186,7 @@ public V getEquivalent(final Object o, final Comparator cmp) { } @Override - public ImmutableMap __put(final K key, final V val) { + public io.usethesource.capsule.Map.Immutable __put(final K key, final V val) { final int keyHash = key.hashCode(); final MapResult details = MapResult.unchanged(); @@ -208,7 +205,7 @@ public ImmutableMap __put(final K key, final V val) { } @Override - public ImmutableMap __putEquivalent(final K key, final V val, + public io.usethesource.capsule.Map.Immutable __putEquivalent(final K key, final V val, final Comparator cmp) { final int keyHash = key.hashCode(); final MapResult details = MapResult.unchanged(); @@ -229,22 +226,24 @@ public ImmutableMap __putEquivalent(final K key, final V val, } @Override - public ImmutableMap __putAll(final Map map) { - final TransientMap tmpTransient = this.asTransient(); + public io.usethesource.capsule.Map.Immutable __putAll( + final Map map) { + final io.usethesource.capsule.Map.Transient tmpTransient = this.asTransient(); tmpTransient.__putAll(map); return tmpTransient.freeze(); } @Override - public ImmutableMap __putAllEquivalent(final Map map, + public io.usethesource.capsule.Map.Immutable __putAllEquivalent( + final Map map, final Comparator cmp) { - final TransientMap tmpTransient = this.asTransient(); + final io.usethesource.capsule.Map.Transient tmpTransient = this.asTransient(); tmpTransient.__putAllEquivalent(map, cmp); return tmpTransient.freeze(); } @Override - public ImmutableMap __remove(final K key) { + public io.usethesource.capsule.Map.Immutable __remove(final K key) { final int keyHash = key.hashCode(); final MapResult details = MapResult.unchanged(); @@ -261,7 +260,8 @@ public ImmutableMap __remove(final K key) { } @Override - public ImmutableMap __removeEquivalent(final K key, final Comparator cmp) { + public io.usethesource.capsule.Map.Immutable __removeEquivalent(final K key, + final Comparator cmp) { final int keyHash = key.hashCode(); final MapResult details = MapResult.unchanged(); @@ -472,19 +472,17 @@ public boolean equals(final Object other) { return false; } - for (@SuppressWarnings("unchecked") - Iterator it = that.entrySet().iterator(); it.hasNext();) { + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { Map.Entry entry = it.next(); try { - @SuppressWarnings("unchecked") final K key = (K) entry.getKey(); final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); if (!result.isPresent()) { return false; } else { - @SuppressWarnings("unchecked") final V val = (V) entry.getValue(); if (!result.get().equals(val)) { @@ -506,7 +504,7 @@ public boolean equals(final Object other) { public int hashCode() { if (hashCode == -1) { int hash = 0; - for (Iterator> it = entryIterator(); it.hasNext();) { + for (Iterator> it = entryIterator(); it.hasNext(); ) { final Map.Entry entry = it.next(); final K key = entry.getKey(); final V val = entry.getValue(); @@ -525,7 +523,7 @@ public boolean isTransientSupported() { } @Override - public TransientMap asTransient() { + public io.usethesource.capsule.Map.Transient asTransient() { return new TransientTrieMap_5Bits_Memoized(this); } @@ -634,6 +632,7 @@ public void printStatistics() { } abstract static class Optional { + private static final Optional EMPTY = new Optional() { @Override boolean isPresent() { @@ -646,7 +645,6 @@ Object get() { } }; - @SuppressWarnings("unchecked") static Optional empty() { return EMPTY; } @@ -660,6 +658,7 @@ static Optional of(T value) { abstract T get(); private static final class Value extends Optional { + private final T value; private Value(T value) { @@ -679,6 +678,7 @@ T get() { } static final class MapResult { + private V replacedValue; private boolean isModified; private boolean isReplaced; @@ -699,7 +699,8 @@ public static MapResult unchanged() { return new MapResult<>(); } - private MapResult() {} + private MapResult() { + } public boolean isModified() { return isModified; @@ -715,6 +716,7 @@ public V getReplacedValue() { } protected static interface INode { + } protected static abstract class AbstractMapNode implements INode { @@ -896,8 +898,8 @@ static final CompactMapNode mergeTwoKeyValPairs(final K key0, final if (shift >= HASH_CODE_LENGTH) { // throw new // IllegalStateException("Hash collision not yet fixed."); - return new HashCollisionMapNode_5Bits<>(keyHash0, (K[]) new Object[] {key0, key1}, - (V[]) new Object[] {val0, val1}); + return new HashCollisionMapNode_5Bits<>(keyHash0, (K[]) new Object[]{key0, key1}, + (V[]) new Object[]{val0, val1}); } final int mask0 = mask(keyHash0, shift); @@ -908,11 +910,11 @@ static final CompactMapNode mergeTwoKeyValPairs(final K key0, final final int dataMap = bitpos(mask0) | bitpos(mask1); if (mask0 < mask1) { - return nodeOf(null, (0), dataMap, new Object[] {key0, val0, key1, val1}, - new int[] {keyHash0, keyHash1}); + return nodeOf(null, (0), dataMap, new Object[]{key0, val0, key1, val1}, + new int[]{keyHash0, keyHash1}); } else { - return nodeOf(null, (0), dataMap, new Object[] {key1, val1, key0, val0}, - new int[] {keyHash1, keyHash0}); + return nodeOf(null, (0), dataMap, new Object[]{key1, val1, key0, val0}, + new int[]{keyHash1, keyHash0}); } } else { final CompactMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, @@ -920,22 +922,23 @@ static final CompactMapNode mergeTwoKeyValPairs(final K key0, final // values fit on next level final int nodeMap = bitpos(mask0); - return nodeOf(null, nodeMap, (0), new Object[] {node}, new int[] {}); + return nodeOf(null, nodeMap, (0), new Object[]{node}, new int[]{}); } } static final CompactMapNode EMPTY_NODE; static { - EMPTY_NODE = new BitmapIndexedMapNode<>(null, (0), (0), new Object[] {}, new int[] {}); - }; + EMPTY_NODE = new BitmapIndexedMapNode<>(null, (0), (0), new Object[]{}, new int[]{}); + } + + ; static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, final int dataMap, final Object[] nodes, final int[] keyHashes) { return new BitmapIndexedMapNode<>(mutator, nodeMap, dataMap, nodes, keyHashes); } - @SuppressWarnings("unchecked") static final CompactMapNode nodeOf(AtomicReference mutator) { return EMPTY_NODE; } @@ -1172,10 +1175,10 @@ CompactMapNode removed(final AtomicReference mutator, final K key, if (dataIndex == 0) { return CompactMapNode.nodeOf(mutator, (0), newDataMap, - new Object[] {getKey(1), getValue(1)}, new int[] {getKeyHash(1)}); + new Object[]{getKey(1), getValue(1)}, new int[]{getKeyHash(1)}); } else { return CompactMapNode.nodeOf(mutator, (0), newDataMap, - new Object[] {getKey(0), getValue(0)}, new int[] {getKeyHash(0)}); + new Object[]{getKey(0), getValue(0)}, new int[]{getKeyHash(0)}); } } else { return copyAndRemoveValue(mutator, bitpos); @@ -1241,10 +1244,10 @@ CompactMapNode removed(final AtomicReference mutator, final K key, if (dataIndex == 0) { return CompactMapNode.nodeOf(mutator, (0), newDataMap, - new Object[] {getKey(1), getValue(1)}, new int[] {getKeyHash(1)}); + new Object[]{getKey(1), getValue(1)}, new int[]{getKeyHash(1)}); } else { return CompactMapNode.nodeOf(mutator, (0), newDataMap, - new Object[] {getKey(0), getValue(0)}, new int[] {getKeyHash(0)}); + new Object[]{getKey(0), getValue(0)}, new int[]{getKeyHash(0)}); } } else { return copyAndRemoveValue(mutator, bitpos); @@ -1397,7 +1400,6 @@ private BitmapIndexedMapNode(final AtomicReference mutator, final int no assert nodeInvariant(); } - @SuppressWarnings("unchecked") @Override K getKey(final int index) { return (K) nodes[TUPLE_LENGTH * index]; @@ -1408,7 +1410,6 @@ int getKeyHash(int index) { return keyHashes[index]; } - @SuppressWarnings("unchecked") @Override V getValue(final int index) { return (V) nodes[TUPLE_LENGTH * index + 1]; @@ -1419,7 +1420,6 @@ Map.Entry getKeyValueEntry(final int index) { return entryOf((K) nodes[TUPLE_LENGTH * index], (V) nodes[TUPLE_LENGTH * index + 1]); } - @SuppressWarnings("unchecked") @Override CompactMapNode getNode(final int index) { return (CompactMapNode) nodes[nodes.length - 1 - index]; @@ -1681,6 +1681,7 @@ private Object[] arraycopyAndMigrateFromNodeToInline(final Object[] src, final i } private static final class HashCollisionMapNode_5Bits extends CompactMapNode { + private final K[] keys; private final V[] vals; private final int hash; @@ -1757,7 +1758,6 @@ CompactMapNode updated(final AtomicReference mutator, final K key, } else { // add new mapping final V[] src = this.vals; - @SuppressWarnings("unchecked") final V[] dst = (V[]) new Object[src.length]; // copy 'src' and set 1 element(s) at position 'idx' @@ -1773,7 +1773,6 @@ CompactMapNode updated(final AtomicReference mutator, final K key, } } - @SuppressWarnings("unchecked") final K[] keysNew = (K[]) new Object[this.keys.length + 1]; // copy 'this.keys' and insert 1 element(s) at position @@ -1783,7 +1782,6 @@ CompactMapNode updated(final AtomicReference mutator, final K key, System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, this.keys.length - keys.length); - @SuppressWarnings("unchecked") final V[] valsNew = (V[]) new Object[this.vals.length + 1]; // copy 'this.vals' and insert 1 element(s) at position @@ -1812,7 +1810,6 @@ CompactMapNode updated(final AtomicReference mutator, final K key, } else { // add new mapping final V[] src = this.vals; - @SuppressWarnings("unchecked") final V[] dst = (V[]) new Object[src.length]; // copy 'src' and set 1 element(s) at position 'idx' @@ -1828,7 +1825,6 @@ CompactMapNode updated(final AtomicReference mutator, final K key, } } - @SuppressWarnings("unchecked") final K[] keysNew = (K[]) new Object[this.keys.length + 1]; // copy 'this.keys' and insert 1 element(s) at position @@ -1838,7 +1834,6 @@ CompactMapNode updated(final AtomicReference mutator, final K key, System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, this.keys.length - keys.length); - @SuppressWarnings("unchecked") final V[] valsNew = (V[]) new Object[this.vals.length + 1]; // copy 'this.vals' and insert 1 element(s) at position @@ -1872,7 +1867,6 @@ CompactMapNode removed(final AtomicReference mutator, final K key, return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, keyHash, 0, details); } else { - @SuppressWarnings("unchecked") final K[] keysNew = (K[]) new Object[this.keys.length - 1]; // copy 'this.keys' and remove 1 element(s) at position @@ -1880,7 +1874,6 @@ CompactMapNode removed(final AtomicReference mutator, final K key, System.arraycopy(this.keys, 0, keysNew, 0, idx); System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); - @SuppressWarnings("unchecked") final V[] valsNew = (V[]) new Object[this.vals.length - 1]; // copy 'this.vals' and remove 1 element(s) at position @@ -1916,7 +1909,6 @@ CompactMapNode removed(final AtomicReference mutator, final K key, return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, keyHash, 0, details, cmp); } else { - @SuppressWarnings("unchecked") final K[] keysNew = (K[]) new Object[this.keys.length - 1]; // copy 'this.keys' and remove 1 element(s) at position @@ -1924,7 +1916,6 @@ CompactMapNode removed(final AtomicReference mutator, final K key, System.arraycopy(this.keys, 0, keysNew, 0, idx); System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); - @SuppressWarnings("unchecked") final V[] valsNew = (V[]) new Object[this.vals.length - 1]; // copy 'this.vals' and remove 1 element(s) at position @@ -2044,7 +2035,8 @@ public boolean equals(Object other) { /* * Linear scan for each key, because of arbitrary element order. */ - outerLoop: for (int i = 0; i < that.payloadArity(); i++) { + outerLoop: + for (int i = 0; i < that.payloadArity(); i++) { final Object otherKey = that.getKey(i); final Object otherVal = that.getValue(i); @@ -2124,7 +2116,6 @@ private static abstract class AbstractMapIterator { private int currentStackLevel = -1; private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; - @SuppressWarnings("unchecked") AbstractMapNode[] nodes = new AbstractMapNode[MAX_DEPTH]; AbstractMapIterator(AbstractMapNode rootNode) { @@ -2305,7 +2296,9 @@ public void remove() { } } - static final class TransientTrieMap_5Bits_Memoized implements TransientMap { + static final class TransientTrieMap_5Bits_Memoized implements + io.usethesource.capsule.Map.Transient { + final private AtomicReference mutator; private AbstractMapNode rootNode; private int cachedSize; @@ -2321,7 +2314,7 @@ private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) int hash = 0; int size = 0; - for (Iterator> it = entryIterator(); it.hasNext();) { + for (Iterator> it = entryIterator(); it.hasNext(); ) { final Map.Entry entry = it.next(); final K key = entry.getKey(); final V val = entry.getValue(); @@ -2356,7 +2349,6 @@ public V remove(final Object key) { @Override public boolean containsKey(final Object o) { try { - @SuppressWarnings("unchecked") final K key = (K) o; return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); } catch (ClassCastException unused) { @@ -2367,7 +2359,6 @@ public boolean containsKey(final Object o) { @Override public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { try { - @SuppressWarnings("unchecked") final K key = (K) o; return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); } catch (ClassCastException unused) { @@ -2377,7 +2368,7 @@ public boolean containsKeyEquivalent(final Object o, final Comparator cm @Override public boolean containsValue(final Object o) { - for (Iterator iterator = valueIterator(); iterator.hasNext();) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { if (iterator.next().equals(o)) { return true; } @@ -2387,7 +2378,7 @@ public boolean containsValue(final Object o) { @Override public boolean containsValueEquivalent(final Object o, final Comparator cmp) { - for (Iterator iterator = valueIterator(); iterator.hasNext();) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { if (cmp.compare(iterator.next(), o) == 0) { return true; } @@ -2398,7 +2389,6 @@ public boolean containsValueEquivalent(final Object o, final Comparator @Override public V get(final Object o) { try { - @SuppressWarnings("unchecked") final K key = (K) o; final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); @@ -2415,7 +2405,6 @@ public V get(final Object o) { @Override public V getEquivalent(final Object o, final Comparator cmp) { try { - @SuppressWarnings("unchecked") final K key = (K) o; final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); @@ -2593,6 +2582,7 @@ public Iterator> entryIterator() { } public static class TransientMapKeyIterator extends MapKeyIterator { + final TransientTrieMap_5Bits_Memoized collection; K lastKey; @@ -2614,6 +2604,7 @@ public void remove() { } public static class TransientMapValueIterator extends MapValueIterator { + final TransientTrieMap_5Bits_Memoized collection; public TransientMapValueIterator(final TransientTrieMap_5Bits_Memoized collection) { @@ -2633,6 +2624,7 @@ public void remove() { } public static class TransientMapEntryIterator extends MapEntryIterator { + final TransientTrieMap_5Bits_Memoized collection; public TransientMapEntryIterator(final TransientTrieMap_5Bits_Memoized collection) { @@ -2800,12 +2792,11 @@ public boolean equals(final Object other) { return false; } - for (@SuppressWarnings("unchecked") - Iterator it = that.entrySet().iterator(); it.hasNext();) { + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { Map.Entry entry = it.next(); try { - @SuppressWarnings("unchecked") final K key = (K) entry.getKey(); final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); @@ -2813,7 +2804,6 @@ public boolean equals(final Object other) { if (!result.isPresent()) { return false; } else { - @SuppressWarnings("unchecked") final V val = (V) entry.getValue(); if (!result.get().equals(val)) { @@ -2834,7 +2824,7 @@ public boolean equals(final Object other) { @Override public int hashCode() { int hash = 0; - for (Iterator> it = entryIterator(); it.hasNext();) { + for (Iterator> it = entryIterator(); it.hasNext(); ) { final Map.Entry entry = it.next(); final K key = entry.getKey(); final V val = entry.getValue(); @@ -2845,7 +2835,7 @@ public int hashCode() { } @Override - public ImmutableMap freeze() { + public io.usethesource.capsule.Map.Immutable freeze() { if (mutator.get() == null) { throw new IllegalStateException("Transient already frozen."); } diff --git a/src/main/java/io/usethesource/capsule/TrieSet_5Bits_Memoized_LazyHashCode.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/memoized/TrieSet_5Bits_Memoized_LazyHashCode.java similarity index 95% rename from src/main/java/io/usethesource/capsule/TrieSet_5Bits_Memoized_LazyHashCode.java rename to capsule-experimental/src/main/java/io/usethesource/capsule/experimental/memoized/TrieSet_5Bits_Memoized_LazyHashCode.java index f83230f..d59d23e 100644 --- a/src/main/java/io/usethesource/capsule/TrieSet_5Bits_Memoized_LazyHashCode.java +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/memoized/TrieSet_5Bits_Memoized_LazyHashCode.java @@ -5,7 +5,7 @@ * This file is licensed under the BSD 2-Clause License, which accompanies this project * and is available under https://opensource.org/licenses/BSD-2-Clause. */ -package io.usethesource.capsule; +package io.usethesource.capsule.experimental.memoized; import java.text.DecimalFormat; import java.util.ArrayDeque; @@ -22,8 +22,11 @@ import java.util.Set; import java.util.concurrent.atomic.AtomicReference; +import io.usethesource.capsule.util.ArrayUtils; +import io.usethesource.capsule.util.ArrayUtilsInt; + @SuppressWarnings("rawtypes") -public class TrieSet_5Bits_Memoized_LazyHashCode implements ImmutableSet { +public class TrieSet_5Bits_Memoized_LazyHashCode implements io.usethesource.capsule.Set.Immutable { @SuppressWarnings("unchecked") private static final TrieSet_5Bits_Memoized_LazyHashCode EMPTY_SET = @@ -44,13 +47,13 @@ public class TrieSet_5Bits_Memoized_LazyHashCode implements ImmutableSet { } @SuppressWarnings("unchecked") - public static final ImmutableSet of() { + public static final io.usethesource.capsule.Set.Immutable of() { return TrieSet_5Bits_Memoized_LazyHashCode.EMPTY_SET; } @SuppressWarnings("unchecked") - public static final ImmutableSet of(K... keys) { - ImmutableSet result = TrieSet_5Bits_Memoized_LazyHashCode.EMPTY_SET; + public static final io.usethesource.capsule.Set.Immutable of(K... keys) { + io.usethesource.capsule.Set.Immutable result = TrieSet_5Bits_Memoized_LazyHashCode.EMPTY_SET; for (final K key : keys) { result = result.__insert(key); @@ -60,13 +63,13 @@ public static final ImmutableSet of(K... keys) { } @SuppressWarnings("unchecked") - public static final TransientSet transientOf() { + public static final io.usethesource.capsule.Set.Transient transientOf() { return TrieSet_5Bits_Memoized_LazyHashCode.EMPTY_SET.asTransient(); } @SuppressWarnings("unchecked") - public static final TransientSet transientOf(K... keys) { - final TransientSet result = TrieSet_5Bits_Memoized_LazyHashCode.EMPTY_SET.asTransient(); + public static final io.usethesource.capsule.Set.Transient transientOf(K... keys) { + final io.usethesource.capsule.Set.Transient result = TrieSet_5Bits_Memoized_LazyHashCode.EMPTY_SET.asTransient(); for (final K key : keys) { result.__insert(key); @@ -150,7 +153,7 @@ public K getEquivalent(final Object o, final Comparator cmp) { } @Override - public ImmutableSet __insert(final K key) { + public io.usethesource.capsule.Set.Immutable __insert(final K key) { final int keyHash = key.hashCode(); final SetResult details = SetResult.unchanged(); @@ -165,7 +168,7 @@ public ImmutableSet __insert(final K key) { } @Override - public ImmutableSet __insertEquivalent(final K key, final Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __insertEquivalent(final K key, final Comparator cmp) { final int keyHash = key.hashCode(); final SetResult details = SetResult.unchanged(); @@ -180,22 +183,22 @@ public ImmutableSet __insertEquivalent(final K key, final Comparator } @Override - public ImmutableSet __insertAll(final Set set) { - final TransientSet tmpTransient = this.asTransient(); + public io.usethesource.capsule.Set.Immutable __insertAll(final Set set) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); tmpTransient.__insertAll(set); return tmpTransient.freeze(); } @Override - public ImmutableSet __insertAllEquivalent(final Set set, - final Comparator cmp) { - final TransientSet tmpTransient = this.asTransient(); + public io.usethesource.capsule.Set.Immutable __insertAllEquivalent(final Set set, + final Comparator cmp) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); tmpTransient.__insertAllEquivalent(set, cmp); return tmpTransient.freeze(); } @Override - public ImmutableSet __remove(final K key) { + public io.usethesource.capsule.Set.Immutable __remove(final K key) { final int keyHash = key.hashCode(); final SetResult details = SetResult.unchanged(); @@ -210,7 +213,7 @@ public ImmutableSet __remove(final K key) { } @Override - public ImmutableSet __removeEquivalent(final K key, final Comparator cmp) { + public io.usethesource.capsule.Set.Immutable __removeEquivalent(final K key, final Comparator cmp) { final int keyHash = key.hashCode(); final SetResult details = SetResult.unchanged(); @@ -225,31 +228,31 @@ public ImmutableSet __removeEquivalent(final K key, final Comparator } @Override - public ImmutableSet __removeAll(final Set set) { - final TransientSet tmpTransient = this.asTransient(); + public io.usethesource.capsule.Set.Immutable __removeAll(final Set set) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); tmpTransient.__removeAll(set); return tmpTransient.freeze(); } @Override - public ImmutableSet __removeAllEquivalent(final Set set, - final Comparator cmp) { - final TransientSet tmpTransient = this.asTransient(); + public io.usethesource.capsule.Set.Immutable __removeAllEquivalent(final Set set, + final Comparator cmp) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); tmpTransient.__removeAllEquivalent(set, cmp); return tmpTransient.freeze(); } @Override - public ImmutableSet __retainAll(final Set set) { - final TransientSet tmpTransient = this.asTransient(); + public io.usethesource.capsule.Set.Immutable __retainAll(final Set set) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); tmpTransient.__retainAll(set); return tmpTransient.freeze(); } @Override - public ImmutableSet __retainAllEquivalent(final TransientSet transientSet, - final Comparator cmp) { - final TransientSet tmpTransient = this.asTransient(); + public io.usethesource.capsule.Set.Immutable __retainAllEquivalent(final io.usethesource.capsule.Set.Transient transientSet, + final Comparator cmp) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); tmpTransient.__retainAllEquivalent(transientSet, cmp); return tmpTransient.freeze(); } @@ -397,7 +400,7 @@ public boolean isTransientSupported() { } @Override - public TransientSet asTransient() { + public io.usethesource.capsule.Set.Transient asTransient() { return new TransientTrieSet_5Bits(this); } @@ -754,6 +757,7 @@ abstract CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference< abstract CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, final int bitpos, final CompactSetNode node); + @SuppressWarnings("unchecked") static final CompactSetNode mergeTwoKeyValPairs(final K key0, final int keyHash0, final K key1, final int keyHash1, final int shift) { // assert !(key0.equals(key1)); @@ -1973,7 +1977,7 @@ public void remove() { } } - static final class TransientTrieSet_5Bits implements TransientSet { + static final class TransientTrieSet_5Bits implements io.usethesource.capsule.Set.Transient { final private AtomicReference mutator; private AbstractSetNode rootNode; private int cachedSize; @@ -1984,6 +1988,7 @@ static final class TransientTrieSet_5Bits implements TransientSet { this.cachedSize = trieSet_5Bits.cachedSize; } + @SuppressWarnings("unused") private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { int hash = 0; int size = 0; @@ -2237,7 +2242,7 @@ public boolean __retainAll(final Set set) { } @Override - public boolean __retainAllEquivalent(final TransientSet transientSet, + public boolean __retainAllEquivalent(final io.usethesource.capsule.Set.Transient transientSet, final Comparator cmp) { boolean modified = false; @@ -2377,7 +2382,7 @@ public int hashCode() { } @Override - public ImmutableSet freeze() { + public io.usethesource.capsule.Set.Immutable freeze() { if (mutator.get() == null) { throw new IllegalStateException("Transient already frozen."); } diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/SetMultimapUtils.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/SetMultimapUtils.java new file mode 100644 index 0000000..33d573a --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/SetMultimapUtils.java @@ -0,0 +1,201 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.multimap; + +import io.usethesource.capsule.api.experimental.Set; +import io.usethesource.capsule.core.PersistentTrieSet; +import io.usethesource.capsule.core.experimental.TrieSet; +import io.usethesource.capsule.experimental.specialized.TrieSet_5Bits_Spec0To8; + +public class SetMultimapUtils { + + public final static int PATTERN_EMPTY = 0b00; + public final static int PATTERN_DATA_SINGLETON = 0b01; + public final static int PATTERN_DATA_COLLECTION = 0b10; + public final static int PATTERN_NODE = 0b11; + + static final long setBitPattern00(final long bitmap, final long doubledBitpos) { + // generally: from xx to 00 + // here: set both bits individually + long updatedBitmap = bitmap; + updatedBitmap |= doubledBitpos; + updatedBitmap ^= doubledBitpos; + updatedBitmap |= (doubledBitpos << 1); + updatedBitmap ^= (doubledBitpos << 1); + return updatedBitmap; + } + + static final long setBitPattern01(final long bitmap, final long doubledBitpos) { + // generally: from xx to 01 + // here: set both bits individually + long updatedBitmap = bitmap; + updatedBitmap |= doubledBitpos; + updatedBitmap |= (doubledBitpos << 1); + updatedBitmap ^= (doubledBitpos << 1); + return updatedBitmap; + } + + static final long setBitPattern10(final long bitmap, final long doubledBitpos) { + // generally: from xx to 10 + // here: set both bits individually + long updatedBitmap = bitmap; + updatedBitmap |= doubledBitpos; + updatedBitmap ^= doubledBitpos; + updatedBitmap |= (doubledBitpos << 1); + return updatedBitmap; + } + + static final long setBitPattern11(final long bitmap, final long doubledBitpos) { + // generally: from xx to 11 + // here: set both bits individually + long updatedBitmap = bitmap; + updatedBitmap |= (doubledBitpos); + updatedBitmap |= (doubledBitpos << 1); + return updatedBitmap; + } + + static final long setBitPattern(final long bitmap, final long doubledBitpos, final int pattern) { + switch (pattern) { + case PATTERN_DATA_SINGLETON: + return setBitPattern01(bitmap, doubledBitpos); + case PATTERN_DATA_COLLECTION: + return setBitPattern10(bitmap, doubledBitpos); + case PATTERN_NODE: + return setBitPattern11(bitmap, doubledBitpos); + default: + return setBitPattern00(bitmap, doubledBitpos); + } + } + + static final long setBitPattern00(final long doubledBitpos) { + // generally: from 00 to 00 + // here: set both bits individually + long updatedBitmap = 0L; + return updatedBitmap; + } + + static final long setBitPattern01(final long doubledBitpos) { + // generally: from 00 to 01 + // here: set both bits individually + long updatedBitmap = 0L; + updatedBitmap |= doubledBitpos; + return updatedBitmap; + } + + static final long setBitPattern10(final long doubledBitpos) { + // generally: from 00 to 10 + // here: set both bits individually + long updatedBitmap = 0L; + updatedBitmap |= (doubledBitpos << 1); + return updatedBitmap; + } + + static final long setBitPattern11(final long doubledBitpos) { + // generally: from 00 to 11 + // here: set both bits individually + long updatedBitmap = 0L; + updatedBitmap |= (doubledBitpos); + updatedBitmap |= (doubledBitpos << 1); + return updatedBitmap; + } + + static final long setBitPattern(final long doubledBitpos, final int pattern) { + switch (pattern) { + case PATTERN_DATA_SINGLETON: + return setBitPattern01(doubledBitpos); + case PATTERN_DATA_COLLECTION: + return setBitPattern10(doubledBitpos); + case PATTERN_NODE: + return setBitPattern11(doubledBitpos); + default: + return setBitPattern00(doubledBitpos); + } + } + + @Deprecated + public static final io.usethesource.capsule.Set.Immutable setFromNode( + PersistentTrieSet.AbstractSetNode rootNode) { + return new PersistentTrieSet<>(rootNode); + } + + @Deprecated + public static final io.usethesource.capsule.Set.Immutable setFromNode( + io.usethesource.capsule.experimental.specialized.TrieSet_5Bits_Spec0To8.AbstractSetNode rootNode) { + return new TrieSet_5Bits_Spec0To8<>(rootNode); + } + + @Deprecated + public static final PersistentTrieSet.AbstractSetNode setNodeOf( + T key1) { + return ((PersistentTrieSet) PersistentTrieSet.of(key1)).getRootNode(); + } + + @Deprecated + public static final io.usethesource.capsule.experimental.specialized.TrieSet_5Bits_Spec0To8.AbstractSetNode specSetNodeOf( + T key1) { + return ((TrieSet_5Bits_Spec0To8) TrieSet_5Bits_Spec0To8.of(key1)).getRootNode(); + } + + @Deprecated + public static final io.usethesource.capsule.experimental.specialized.TrieSet_5Bits_Spec0To8.AbstractSetNode specSetNodeOf( + T key1, T key2) { + return ((TrieSet_5Bits_Spec0To8) TrieSet_5Bits_Spec0To8.of(key1, key2)).getRootNode(); + } + + @Deprecated + public static final PersistentTrieSet.AbstractSetNode setToNode( + io.usethesource.capsule.Set.Immutable set) { + return ((PersistentTrieSet) set).getRootNode(); + } + + @Deprecated + public static final io.usethesource.capsule.experimental.specialized.TrieSet_5Bits_Spec0To8.AbstractSetNode specSetToNode( + io.usethesource.capsule.Set.Immutable set) { + return ((TrieSet_5Bits_Spec0To8) set).getRootNode(); + } + + + @Deprecated + public static final PersistentTrieSet.AbstractSetNode setNodeOf(T key1, + T key2) { + return ((PersistentTrieSet) PersistentTrieSet.of(key1, key2)).getRootNode(); + } + + @Deprecated + public static final io.usethesource.capsule.Set.Immutable setOf(T key1) { + return PersistentTrieSet.of(key1); + } + + @Deprecated + public static final io.usethesource.capsule.Set.Immutable setOf(T key1, T key2) { + return PersistentTrieSet.of(key1, key2); + } + + @Deprecated + public static final io.usethesource.capsule.Set.Immutable specSetOf(T key1) { + return TrieSet_5Bits_Spec0To8.of(key1); + } + + @Deprecated + public static final io.usethesource.capsule.Set.Immutable specSetOf(T key1, T key2) { + return TrieSet_5Bits_Spec0To8.of(key1, key2); + } + + public static final Set.Immutable setOfNew() { + return TrieSet.of(); + } + + public static final Set.Immutable setOfNew(T key1) { + return TrieSet.of(key1); + } + + public static final Set.Immutable setOfNew(T key1, T key2) { + return TrieSet.of(key1, key2); + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieMap_5Bits_AsSetMultimap.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieMap_5Bits_AsSetMultimap.java new file mode 100644 index 0000000..3c1b757 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieMap_5Bits_AsSetMultimap.java @@ -0,0 +1,2801 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.multimap; + +import java.text.DecimalFormat; +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.BiFunction; + +import io.usethesource.capsule.SetMultimap; +import io.usethesource.capsule.util.ArrayUtils; +import io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableSet; + +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +public class TrieMap_5Bits_AsSetMultimap implements SetMultimap.Immutable { + + private static final TrieMap_5Bits_AsSetMultimap EMPTY_MAP = + new TrieMap_5Bits_AsSetMultimap(CompactMapNode.EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractMapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieMap_5Bits_AsSetMultimap(AbstractMapNode rootNode, int hashCode, int cachedSize) { + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final SetMultimap.Immutable of() { + return TrieMap_5Bits_AsSetMultimap.EMPTY_MAP; + } + + public static final SetMultimap.Immutable of(K key, V... values) { + SetMultimap.Immutable result = TrieMap_5Bits_AsSetMultimap.EMPTY_MAP; + + for (V value : values) { + result = result.__insert(key, value); + } + + return result; + } + + public static final SetMultimap.Transient transientOf() { + return TrieMap_5Bits_AsSetMultimap.EMPTY_MAP.asTransient(); + } + + public static final SetMultimap.Transient transientOf(K key, V... values) { + final SetMultimap.Transient result = TrieMap_5Bits_AsSetMultimap.EMPTY_MAP.asTransient(); + + for (V value : values) { + result.__insert(key, value); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get().equals(val); + } else { + return false; + } + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return AbstractSpecialisedImmutableSet.setOf(result.get()); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable getEquivalent(final Object o, + final Comparator cmp) { + try { + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return AbstractSpecialisedImmutableSet.setOf(result.get()); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public SetMultimap.Immutable __put(final K key, final V val) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieMap_5Bits_AsSetMultimap(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val.hashCode(); + return new TrieMap_5Bits_AsSetMultimap(newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable __insert(final K key, final V val) { + return __put(key, val); // NOTE: semantically incorrect + } + + @Override + public SetMultimap.Immutable __insertEquivalent(final K key, final V val, + final Comparator cmp) { + throw new UnsupportedOperationException(); + } + + @Override + public SetMultimap.Immutable union(final SetMultimap map) { + final SetMultimap.Transient tmpTransient = this.asTransient(); + tmpTransient.union(map); + return tmpTransient.freeze(); + } + + @Override + public SetMultimap.Immutable __remove(K key, V val) { + return __remove(key); // NOTE performs remove all (unchecked of val) + } + + @Override + public SetMultimap.Immutable __remove(final K key) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieMap_5Bits_AsSetMultimap(newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable __removeEquivalent(final K key, final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieMap_5Bits_AsSetMultimap(newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); + } + + return this; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new MapKeyIterator<>(rootNode); + } + + @Override + public Iterator valueIterator() { + return new MapValueIterator<>(rootNode); + } + + @Override + public Iterator> entryIterator() { + return new MapEntryIterator<>(rootNode); + } + + @Override + public Iterator> nativeEntryIterator() { + return (Iterator>) (Object) new MapEntryIterator<>(rootNode); + } + + @Override + public Iterator tupleIterator(BiFunction tupleOf) { + throw new UnsupportedOperationException(); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_AsSetMultimap.this.keyIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_AsSetMultimap.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_AsSetMultimap.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_AsSetMultimap.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_AsSetMultimap.this.valueIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_AsSetMultimap.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_AsSetMultimap.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TrieMap_5Bits_AsSetMultimap.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieMap_5Bits_AsSetMultimap.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_AsSetMultimap.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_AsSetMultimap.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieMap_5Bits_AsSetMultimap) { + TrieMap_5Bits_AsSetMultimap that = (TrieMap_5Bits_AsSetMultimap) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + final V val = (V) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public SetMultimap.Transient asTransient() { + return new TransientTrieMap_5Bits(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractMapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieMap_5BitsNodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. Payload X Node + */ + protected int[][] arityCombinationsHistogram() { + final Iterator> it = nodeIterator(); + final int[][] sumArityCombinations = new int[33][33]; + + while (it.hasNext()) { + final AbstractMapNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[33]; + + final int maxArity = 32; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[33]; + for (int cumsum = 0, i = 0; i < 33; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 33; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + abstract static class Optional { + + private static final Optional EMPTY = new Optional() { + @Override + boolean isPresent() { + return false; + } + + @Override + Object get() { + return null; + } + }; + + static Optional empty() { + return EMPTY; + } + + static Optional of(T value) { + return new Value(value); + } + + abstract boolean isPresent(); + + abstract T get(); + + private static final class Value extends Optional { + + private final T value; + + private Value(T value) { + this.value = value; + } + + @Override + boolean isPresent() { + return true; + } + + @Override + T get() { + return value; + } + } + } + + static final class MapResult { + + private V replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(V replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static MapResult unchanged() { + return new MapResult<>(); + } + + private MapResult() { + } + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public V getReplacedValue() { + return replacedValue; + } + } + + protected static interface INode { + + } + + protected static abstract class AbstractMapNode implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final K key, final int keyHash, final int shift); + + abstract boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final K key, final int keyHash, final int shift); + + abstract Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract CompactMapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + abstract CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractMapNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractMapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractMapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract K getKey(final int index); + + abstract V getValue(final int index); + + abstract Map.Entry getKeyValueEntry(final int index); + + @Deprecated + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + int size() { + final Iterator it = new MapKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactMapNode extends AbstractMapNode { + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + abstract int nodeMap(); + + abstract int dataMap(); + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactMapNode getNode(final int index); + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactMapNode copyAndSetValue(final AtomicReference mutator, + final int bitpos, final V val); + + abstract CompactMapNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final K key, final V val); + + abstract CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos); + + abstract CompactMapNode copyAndSetNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromInlineToNode( + final AtomicReference mutator, final int bitpos, final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromNodeToInline( + final AtomicReference mutator, final int bitpos, final CompactMapNode node); + + static final CompactMapNode mergeTwoKeyValPairs(final K key0, final V val0, + final int keyHash0, final K key1, final V val1, final int keyHash1, final int shift) { + assert !(key0.equals(key1)); + + if (shift >= HASH_CODE_LENGTH) { + // throw new + // IllegalStateException("Hash collision not yet fixed."); + return new HashCollisionMapNode_5Bits<>(keyHash0, (K[]) new Object[]{key0, key1}, + (V[]) new Object[]{val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int dataMap = bitpos(mask0) | bitpos(mask1); + + if (mask0 < mask1) { + return nodeOf(null, (0), dataMap, new Object[]{key0, val0, key1, val1}); + } else { + return nodeOf(null, (0), dataMap, new Object[]{key1, val1, key0, val0}); + } + } else { + final CompactMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, + keyHash1, shift + BIT_PARTITION_SIZE); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf(null, nodeMap, (0), new Object[]{node}); + } + } + + static final CompactMapNode EMPTY_NODE; + + static { + + EMPTY_NODE = new BitmapIndexedMapNode<>(null, (0), (0), new Object[]{}); + + } + + ; + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object[] nodes) { + return new BitmapIndexedMapNode<>(mutator, nodeMap, dataMap, nodes); + } + + static final CompactMapNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactMapNode nodeOf(AtomicReference mutator, + final int nodeMap, final int dataMap, final K key, final V val) { + assert nodeMap == 0; + return nodeOf(mutator, (0), dataMap, new Object[]{key, val}); + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + CompactMapNode nodeAt(final int bitpos) { + return getNode(nodeIndex(bitpos)); + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index).equals(key); + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return false; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return cmp.compare(getKey(index), key) == 0; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index).equals(key)) { + final V result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (cmp.compare(getKey(index), key) == 0) { + final V result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return Optional.empty(); + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (currentKey.equals(key)) { + final V currentVal = getValue(dataIndex); + + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } else { + final V currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (cmp.compare(currentKey, key) == 0) { + final V currentVal = getValue(dataIndex); + + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } else { + final V currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex).equals(key)) { + final V currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(1), getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(0), getValue(0)); + } + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (this.payloadArity() == 0 && this.nodeArity() == 1) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (cmp.compare(getKey(dataIndex), key) == 0) { + final V currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(1), getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, 0, newDataMap, getKey(0), getValue(0)); + } + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (this.payloadArity() == 0 && this.nodeArity() == 1) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getKey(i)), + Objects.hashCode(getValue(i)))); + + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedMapNode extends CompactMapNode { + + private final int nodeMap; + private final int dataMap; + + CompactMixedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + private static final class BitmapIndexedMapNode extends CompactMixedMapNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + super(mutator, nodeMap, dataMap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + + assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < TUPLE_LENGTH * payloadArity(); i++) { + assert ((nodes[i] instanceof CompactMapNode) == false); + } + for (int i = TUPLE_LENGTH * payloadArity(); i < nodes.length; i++) { + assert ((nodes[i] instanceof CompactMapNode) == true); + } + } + + assert nodeInvariant(); + } + + @Override + K getKey(final int index) { + return (K) nodes[TUPLE_LENGTH * index]; + } + + @Override + V getValue(final int index) { + return (V) nodes[TUPLE_LENGTH * index + 1]; + } + + @Override + Map.Entry getKeyValueEntry(final int index) { + return entryOf((K) nodes[TUPLE_LENGTH * index], (V) nodes[TUPLE_LENGTH * index + 1]); + } + + @Override + CompactMapNode getNode(final int index) { + return (CompactMapNode) nodes[nodes.length - 1 - index]; + } + + @Override + boolean hasPayload() { + return dataMap() != 0; + } + + @Override + int payloadArity() { + return java.lang.Integer.bitCount(dataMap()); + } + + @Override + boolean hasNodes() { + return nodeMap() != 0; + } + + @Override + int nodeArity() { + return java.lang.Integer.bitCount(nodeMap()); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + (nodeMap()); + result = prime * result + (dataMap()); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedMapNode that = (BitmapIndexedMapNode) other; + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + if (!ArrayUtils.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + if (this.nodeArity() == 0) { + switch (this.payloadArity()) { + case 0: + return SIZE_EMPTY; + case 1: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } else { + return SIZE_MORE_THAN_ONE; + } + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos) + 1; + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = val; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(bitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = val; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + return nodeOf(mutator, nodeMap(), dataMap() | bitpos, dst); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + return nodeOf(mutator, nodeMap(), dataMap() ^ bitpos, dst); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2 + 1]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 2, dst, idxNew + 1, src.length - idxNew - 2); + + return nodeOf(mutator, nodeMap() | bitpos, dataMap() ^ bitpos, dst); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 2]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = node.getKey(0); + dst[idxNew + 1] = node.getValue(0); + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 2, src.length - idxOld - 1); + + return nodeOf(mutator, nodeMap() ^ bitpos, dataMap() | bitpos, dst); + } + + } + + private static final class HashCollisionMapNode_5Bits extends CompactMapNode { + + private final K[] keys; + private final V[] vals; + private final int hash; + + HashCollisionMapNode_5Bits(final int hash, final K[] keys, final V[] vals) { + this.keys = keys; + this.vals = vals; + this.hash = hash; + + assert payloadArity() >= 2; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (K k : keys) { + if (k.equals(key)) { + return true; + } + } + } + return false; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (K k : keys) { + if (cmp.compare(k, key) == 0) { + return true; + } + } + } + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (key.equals(_key)) { + final V val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (cmp.compare(key, _key) == 0) { + final V val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final V currentVal = vals[idx]; + + if (currentVal.equals(val)) { + return this; + } else { + // add new mapping + final V[] src = this.vals; + final V[] dst = (V[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode_5Bits<>(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final V[] valsNew = (V[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits<>(keyHash, keysNew, valsNew); + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final V currentVal = vals[idx]; + + if (cmp.compare(currentVal, val) == 0) { + return this; + } else { + // add new mapping + final V[] src = this.vals; + final V[] dst = (V[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode_5Bits<>(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final V[] valsNew = (V[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits<>(keyHash, keysNew, valsNew); + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final V currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final V theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details); + } else { + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final V[] valsNew = (V[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits<>(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final V currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final V theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details, cmp); + } else { + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final V[] valsNew = (V[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits<>(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return keys.length; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + int arity() { + return payloadArity(); + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + K getKey(final int index) { + return keys[index]; + } + + @Override + V getValue(final int index) { + return vals[index]; + } + + @Override + Map.Entry getKeyValueEntry(final int index) { + return entryOf(keys[index], vals[index]); + } + + @Override + public CompactMapNode getNode(int index) { + throw new IllegalStateException("Is leaf node."); + } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + hash; + result = prime * result + Arrays.hashCode(keys); + result = prime * result + Arrays.hashCode(vals); + return result; + } + + @Override + public boolean equals(Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + HashCollisionMapNode_5Bits that = (HashCollisionMapNode_5Bits) other; + + if (hash != that.hash) { + return false; + } + + if (arity() != that.arity()) { + return false; + } + + /* + * Linear scan for each key, because of arbitrary element order. + */ + outerLoop: + for (int i = 0; i < that.payloadArity(); i++) { + final Object otherKey = that.getKey(i); + final Object otherVal = that.getValue(i); + + for (int j = 0; j < keys.length; j++) { + final K key = keys[j]; + final V val = vals[j]; + + if (key.equals(otherKey) && val.equals(otherVal)) { + continue outerLoop; + } + } + return false; + } + + return true; + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + int nodeMap() { + throw new UnsupportedOperationException(); + } + + @Override + int dataMap() { + throw new UnsupportedOperationException(); + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractMapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractMapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractMapNode[] nodes = new AbstractMapNode[MAX_DEPTH]; + + AbstractMapIterator(AbstractMapNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractMapNode nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class MapKeyIterator extends AbstractMapIterator + implements Iterator { + + MapKeyIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + protected static class MapValueIterator extends AbstractMapIterator + implements Iterator { + + MapValueIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public V next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getValue(currentValueCursor++); + } + } + + } + + protected static class MapEntryIterator extends AbstractMapIterator + implements Iterator> { + + MapEntryIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKeyValueEntry(currentValueCursor++); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieMap_5BitsNodeIterator implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieMap_5BitsNodeIterator(AbstractMapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractMapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieMap_5Bits implements SetMultimap.Transient { + + final private AtomicReference mutator; + private AbstractMapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieMap_5Bits(TrieMap_5Bits_AsSetMultimap trieMap_5Bits) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieMap_5Bits.rootNode; + this.hashCode = trieMap_5Bits.hashCode; + this.cachedSize = trieMap_5Bits.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean __remove(K key, V val) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get().equals(val); + } else { + return false; + } + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return AbstractSpecialisedImmutableSet.setOf(result.get()); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable getEquivalent(final Object o, + final Comparator cmp) { + try { + final K key = (K) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return AbstractSpecialisedImmutableSet.setOf(result.get()); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public boolean __insert(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final V old = details.getReplacedValue(); + + final int valHashOld = old.hashCode(); + final int valHashNew = val.hashCode(); + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } else { + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean __insertEquivalent(final K key, final V val, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final V old = details.getReplacedValue(); + + final int valHashOld = old.hashCode(); + final int valHashNew = val.hashCode(); + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } else { + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean union(final SetMultimap map) { + boolean modified = false; + + for (Map.Entry entry : map.entrySet()) { + modified |= this.__insert(entry.getKey(), entry.getValue()); + } + + return modified; + } + + public boolean __insertAllEquivalent(final SetMultimap map, + final Comparator cmp) { + boolean modified = false; + + for (Map.Entry entry : map.entrySet()) { + modified |= this.__insertEquivalent(entry.getKey(), entry.getValue(), cmp); + } + + return modified; + } + + @Override + public boolean __remove(final K key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + // return DefaultTrieSet.of(details.getReplacedValue()); + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + // return null; + return false; + } + + @Override + public boolean __removeEquivalent(final K key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + // return details.getReplacedValue(); + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + // return null; + return false; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new TransientSetMultimapKeyIterator<>(this); + } + + @Override + public Iterator valueIterator() { + return new TransientSetMultimapValueIterator<>(this); + } + + @Override + public Iterator> entryIterator() { + return new TransientSetMultimapEntryIterator<>(this); + } + + @Override + public Iterator tupleIterator(BiFunction tupleOf) { + throw new UnsupportedOperationException(); + } + + public static class TransientSetMultimapKeyIterator extends MapKeyIterator { + + final TransientTrieMap_5Bits collection; + K lastKey; + + public TransientSetMultimapKeyIterator(final TransientTrieMap_5Bits collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(lastKey); + } + } + + public static class TransientSetMultimapValueIterator extends MapValueIterator { + + final TransientTrieMap_5Bits collection; + + public TransientSetMultimapValueIterator(final TransientTrieMap_5Bits collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public V next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapEntryIterator extends MapEntryIterator { + + final TransientTrieMap_5Bits collection; + + public TransientSetMultimapEntryIterator(final TransientTrieMap_5Bits collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public Map.Entry next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieMap_5Bits.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieMap_5Bits.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieMap_5Bits) { + TransientTrieMap_5Bits that = (TransientTrieMap_5Bits) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + final V val = (V) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public SetMultimap.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieMap_5Bits_AsSetMultimap(rootNode, hashCode, cachedSize); + } + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap.java new file mode 100644 index 0000000..2dca594 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap.java @@ -0,0 +1,3920 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.multimap; + +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Optional; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import io.usethesource.capsule.api.experimental.Set; +import io.usethesource.capsule.api.experimental.SetMultimap; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap.EitherSingletonOrCollection.Type; +import io.usethesource.capsule.util.EqualityComparator; +import io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap; + +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_DATA_COLLECTION; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_DATA_SINGLETON; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_EMPTY; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_NODE; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setBitPattern; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setOf; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setOfNew; +import static io.usethesource.capsule.experimental.multimap.TrieSetMultimap.EitherSingletonOrCollection.Type.COLLECTION; +import static io.usethesource.capsule.experimental.multimap.TrieSetMultimap.EitherSingletonOrCollection.Type.SINGLETON; +import static io.usethesource.capsule.util.BitmapUtils.filter; +import static io.usethesource.capsule.util.BitmapUtils.index; +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +@SuppressWarnings("rawtypes") +public class TrieSetMultimap implements SetMultimap.Immutable { + + private final EqualityComparator cmp; + + @SuppressWarnings("unchecked") + private static final TrieSetMultimap EMPTY_SETMULTIMAP = + new TrieSetMultimap(EqualityComparator.EQUALS, CompactSetMultimapNode.EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractSetMultimapNode rootNode; + private final int cachedHashCode; + private final int cachedSize; + + TrieSetMultimap(EqualityComparator cmp, AbstractSetMultimapNode rootNode, + int hashCode, long cachedSize) { + this.cmp = cmp; + this.rootNode = rootNode; + this.cachedHashCode = hashCode; + this.cachedSize = Math.toIntExact(cachedSize); // does not support long yet + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + @SuppressWarnings("unchecked") + public static final SetMultimap.Immutable of() { + return TrieSetMultimap.EMPTY_SETMULTIMAP; + } + + @SuppressWarnings("unchecked") + public static final SetMultimap.Immutable of(K key, V... values) { + SetMultimap.Immutable result = TrieSetMultimap.EMPTY_SETMULTIMAP; + + for (V value : values) { + result = result.insert(key, value); + } + + return result; + } + + @SuppressWarnings("unchecked") + public static final SetMultimap.Transient transientOf() { + return TrieSetMultimap.EMPTY_SETMULTIMAP.asTransient(); + } + + @SuppressWarnings("unchecked") + public static final SetMultimap.Transient transientOf(K key, V... values) { + final SetMultimap.Transient result = TrieSetMultimap.EMPTY_SETMULTIMAP.asTransient(); + + for (V value : values) { + result.insert(key, value); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final long targetSize) { + int hash = 0; + long size = 0; + + for (Map.Entry entry : this) { + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash ^= key.hashCode(); + hash ^= val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean contains(final K key) { + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } + + @Override + public boolean contains(final K key, final V val) { + return rootNode.containsTuple(key, val, transformHashCode(key.hashCode()), 0, cmp); + } + + // @Override + // public boolean containsValue(final Object o) { + // for (Iterator iterator = valueIterator(); iterator.hasNext();) { + // if (iterator.next().equals(o)) { + // return true; + // } + // } + // return false; + // } + + // @Override + // public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + // for (Iterator iterator = valueIterator(); iterator.hasNext();) { + // if (cmp.compare(iterator.next(), o) == 0) { + // return true; + // } + // } + // return false; + // } + + @Override + public Optional> apply(K key) { + return rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + } + + // @Override + // public Set.Immutable get(final Object o) { + // try { + // @SuppressWarnings("unchecked") + // final K key = (K) o; + // final Optional> result = + // rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + // + // if (result.isPresent()) { + // return result.get(); + // } else { + // return null; + // } + // } catch (ClassCastException unused) { + // return null; + // } + // } + // + // @Override + // public Set.Immutable getEquivalent(final Object o, final Comparator cmp) { + // throw new UnsupportedOperationException("Not yet implemented."); + // } + + @Override + public SetMultimap.Immutable put(K key, V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieSetMultimap(cmp, newRootNode, + cachedHashCode ^ ((keyHash ^ valHashNew)) ^ ((keyHash ^ valHashOld)), cachedSize); + } else { + final int sumOfReplacedHashes; + + if ((1 + details.getReplacedCollection().size()) % 2 == 0) { + sumOfReplacedHashes = details.getReplacedCollection().hashCode(); + } else { + sumOfReplacedHashes = details.getReplacedCollection().hashCode() ^ keyHash; + } + + final int valHashNew = val.hashCode(); + + return new TrieSetMultimap(cmp, newRootNode, + cachedHashCode ^ ((keyHash ^ valHashNew)) ^ sumOfReplacedHashes, + cachedSize - details.getReplacedCollection().size() + 1); + } + } + + final int valHash = val.hashCode(); + return new TrieSetMultimap(cmp, newRootNode, cachedHashCode ^ ((keyHash ^ valHash)), + cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable put(final K key, final Set values) { + throw new UnsupportedOperationException("Not yet implemented."); + } + + @Override + public SetMultimap.Immutable insert(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + final int valHash = val.hashCode(); + return new TrieSetMultimap(cmp, newRootNode, cachedHashCode ^ ((keyHash ^ valHash)), + cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable insert(final K key, final Set values) { + throw new UnsupportedOperationException("Not yet implemented."); + } + + @Override + public SetMultimap.Immutable remove(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap(cmp, newRootNode, cachedHashCode ^ ((keyHash ^ valHash)), + cachedSize - 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable remove(K key) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removedAll(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap(cmp, newRootNode, cachedHashCode ^ ((keyHash ^ valHash)), + cachedSize - 1); + } else { + final int sumOfReplacedHashes; + + if ((details.getReplacedCollection().size()) % 2 == 0) { + sumOfReplacedHashes = details.getReplacedCollection().hashCode(); + } else { + sumOfReplacedHashes = details.getReplacedCollection().hashCode() ^ keyHash; + } + + return new TrieSetMultimap(cmp, newRootNode, cachedHashCode ^ sumOfReplacedHashes, + cachedSize - details.getReplacedCollection().size()); + } + } + + return this; + } + + @Override + public SetMultimap.Immutable union( + final SetMultimap setMultimap) { + final SetMultimap.Transient tmpTransient = this.asTransient(); + tmpTransient.union(setMultimap); + return tmpTransient.asImmutable(); + } + + @Override + public SetMultimap.Immutable intersect( + final SetMultimap setMultimap) { + final SetMultimap.Transient tmpTransient = this.asTransient(); + tmpTransient.intersect(setMultimap); + return tmpTransient.asImmutable(); + } + + @Override + public SetMultimap.Immutable complement( + final SetMultimap setMultimap) { + final SetMultimap.Transient tmpTransient = this.asTransient(); + tmpTransient.complement(setMultimap); + return tmpTransient.asImmutable(); + } + + // @Override + // public V put(final K key, final V val) { + // throw new UnsupportedOperationException(); + // } + // + // @Override + // public void putAll(final SetMultimap m) { + // throw new UnsupportedOperationException(); + // } + // + // @Override + // public void clear() { + // throw new UnsupportedOperationException(); + // } + // + // @Override + // public V remove(final Object key, final Object val) { + // throw new UnsupportedOperationException(); + // } + + @Override + public long size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator> iterator() { + return new SetMultimapTupleIterator<>(rootNode, AbstractSpecialisedImmutableMap::entryOf); + } + + // @Override + // public Iterator keyIterator() { + // return new SetMultimapKeyIterator<>(rootNode); + // } + // + // @Override + // public Iterator valueIterator() { + // return valueCollectionsStream().flatMap(Set::stream).iterator(); + // } + // + // @Override + // public Iterator> entryIterator() { + // return new SetMultimapTupleIterator<>(rootNode, AbstractSpecialisedImmutableMap::entryOf); + // } + + @Override + public Iterator> nativeEntryIterator() { + return new SetMultimapNativeTupleIterator<>(rootNode); + } + + // @Override + // public Iterator tupleIterator(final BiFunction tupleOf) { + // return new SetMultimapTupleIterator<>(rootNode, tupleOf); + // } + // + // private Spliterator> valueCollectionsSpliterator() { + // /* + // * TODO: specialize between mutable / immutable ({@see Spliterator.IMMUTABLE}) + // */ + // int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + // return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + // characteristics); + // } + // + // private Stream> valueCollectionsStream() { + // boolean isParallel = false; + // return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + // } + + // @Override + // public Set keySet() { + // Set keySet = null; + // + // if (keySet == null) { + // keySet = new AbstractSet() { + // @Override + // public Iterator iterator() { + // return TrieSetMultimap.this.keyIterator(); + // } + // + // @Override + // public int size() { + // return TrieSetMultimap.this.sizeDistinct(); + // } + // + // @Override + // public boolean isEmpty() { + // return TrieSetMultimap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // TrieSetMultimap.this.clear(); + // } + // + // @Override + // public boolean contains(Object k) { + // return TrieSetMultimap.this.containsKey(k); + // } + // }; + // } + // + // return keySet; + // } + // + // @Override + // public Collection values() { + // Collection values = null; + // + // if (values == null) { + // values = new AbstractCollection() { + // @Override + // public Iterator iterator() { + // return TrieSetMultimap.this.valueIterator(); + // } + // + // @Override + // public int size() { + // return TrieSetMultimap.this.size(); + // } + // + // @Override + // public boolean isEmpty() { + // return TrieSetMultimap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // TrieSetMultimap.this.clear(); + // } + // + // @Override + // public boolean contains(Object v) { + // return TrieSetMultimap.this.containsValue(v); + // } + // }; + // } + // + // return values; + // } + // + // @Override + // public Set> entrySet() { + // Set> entrySet = null; + // + // if (entrySet == null) { + // entrySet = new AbstractSet>() { + // @Override + // public Iterator> iterator() { + // return new Iterator>() { + // private final Iterator> i = entryIterator(); + // + // @Override + // public boolean hasNext() { + // return i.hasNext(); + // } + // + // @Override + // public Map.Entry next() { + // return i.next(); + // } + // + // @Override + // public void remove() { + // i.remove(); + // } + // }; + // } + // + // @Override + // public int size() { + // return TrieSetMultimap.this.size(); + // } + // + // @Override + // public boolean isEmpty() { + // return TrieSetMultimap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // TrieSetMultimap.this.clear(); + // } + // + // @Override + // public boolean contains(Object k) { + // return TrieSetMultimap.this.containsKey(k); + // } + // }; + // } + // + // return entrySet; + // } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieSetMultimap) { + TrieSetMultimap that = (TrieSetMultimap) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.cachedHashCode != that.cachedHashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + try { + @SuppressWarnings("unchecked") + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) + return false; + + for (Map.Entry entry : that) { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + @SuppressWarnings("unchecked") + final Set.Immutable valColl = (Set.Immutable) entry.getValue(); + if (!result.get().equals(valColl)) { + return false; + } + } + } + } catch (ClassCastException unused) { + return false; + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return cachedHashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public SetMultimap.Transient asTransient() { + return new TransientTrieSetMultimap(this); + } + + @Override + public SetMultimap.Immutable asImmutable() { + return this; + } + + /* + * For analysis purposes only. + */ + protected AbstractSetMultimapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieSetMultimapNodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + // /* + // * For analysis purposes only. Payload X Node + // */ + // protected int[][] arityCombinationsHistogram() { + // final Iterator> it = nodeIterator(); + // final int[][] sumArityCombinations = new int[33][33]; + // + // while (it.hasNext()) { + // final AbstractSetMultimapNode node = it.next(); + // sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + // } + // + // return sumArityCombinations; + // } + // + // /* + // * For analysis purposes only. + // */ + // protected int[] arityHistogram() { + // final int[][] sumArityCombinations = arityCombinationsHistogram(); + // final int[] sumArity = new int[33]; + // + // final int maxArity = 32; // TODO: factor out constant + // + // for (int j = 0; j <= maxArity; j++) { + // for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + // sumArity[j + k] += sumArityCombinations[j][k]; + // } + // } + // + // return sumArity; + // } + // + // /* + // * For analysis purposes only. + // */ + // public void printStatistics() { + // final int[][] sumArityCombinations = arityCombinationsHistogram(); + // final int[] sumArity = arityHistogram(); + // final int sumNodes = getNodeCount(); + // + // final int[] cumsumArity = new int[33]; + // for (int cumsum = 0, i = 0; i < 33; i++) { + // cumsum += sumArity[i]; + // cumsumArity[i] = cumsum; + // } + // + // final float threshhold = 0.01f; // for printing results + // for (int i = 0; i < 33; i++) { + // float arityPercentage = (float) (sumArity[i]) / sumNodes; + // float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + // + // if (arityPercentage != 0 && arityPercentage >= threshhold) { + // // details per level + // StringBuilder bldr = new StringBuilder(); + // int max = i; + // for (int j = 0; j <= max; j++) { + // for (int k = max - j; k <= max - j; k++) { + // float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + // + // if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + // bldr.append(String.format("%d/%d: %s, ", j, k, + // new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + // } + // } + // } + // final String detailPercentages = bldr.toString(); + // + // // overview + // System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + // new DecimalFormat("0.00%").format(arityPercentage), + // new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + // } + // } + // } + + static abstract class EitherSingletonOrCollection { + public enum Type { + SINGLETON, COLLECTION + } + + public static final EitherSingletonOrCollection of(T value) { + return new SomeSingleton<>(value); + } + + public static final EitherSingletonOrCollection of(Set.Immutable value) { + return new SomeCollection<>(value); + } + + abstract boolean isType(Type type); + + abstract T getSingleton(); + + abstract Set.Immutable getCollection(); + } + + static final class SomeSingleton extends EitherSingletonOrCollection { + private final T value; + + private SomeSingleton(T value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.SINGLETON; + } + + @Override + T getSingleton() { + return value; + } + + @Override + Set.Immutable getCollection() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.COLLECTION, Type.SINGLETON)); + } + } + + static final class SomeCollection extends EitherSingletonOrCollection { + private final Set.Immutable value; + + private SomeCollection(Set.Immutable value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.COLLECTION; + } + + @Override + T getSingleton() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.SINGLETON, Type.COLLECTION)); + } + + @Override + Set.Immutable getCollection() { + return value; + } + } + + static final class SetMultimapResult { + private V replacedValue; + private Set.Immutable replacedValueCollection; + private EitherSingletonOrCollection.Type replacedType; + + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(V replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + this.replacedType = SINGLETON; + } + + public void updated(Set.Immutable replacedValueCollection) { + this.replacedValueCollection = replacedValueCollection; + this.isModified = true; + this.isReplaced = true; + this.replacedType = COLLECTION; + } + + // update: neither element, nor element count changed + public static SetMultimapResult unchanged() { + return new SetMultimapResult<>(); + } + + private SetMultimapResult() {} + + public boolean isModified() { + return isModified; + } + + public EitherSingletonOrCollection.Type getType() { + return replacedType; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public V getReplacedValue() { + assert getType() == SINGLETON; + return replacedValue; + } + + public Set.Immutable getReplacedCollection() { + assert getType() == COLLECTION; + return replacedValueCollection; + } + } + + protected static interface INode { + } + + protected static abstract class AbstractSetMultimapNode implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final K key, final int keyHash, final int shift, + final EqualityComparator cmp); + + abstract boolean containsTuple(final K key, final V val, final int keyHash, final int shift, + final EqualityComparator cmp); + + abstract Optional> findByKey(final K key, final int keyHash, final int shift, + final EqualityComparator cmp); + + abstract CompactSetMultimapNode inserted(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, final EqualityComparator cmp); + + abstract CompactSetMultimapNode updated(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, final EqualityComparator cmp); + + abstract CompactSetMultimapNode updated(final AtomicReference mutator, + final K key, final Set val, final int keyHash, final int shift, + final SetMultimapResult details, final EqualityComparator cmp); + + abstract CompactSetMultimapNode removed(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, final EqualityComparator cmp); + + abstract CompactSetMultimapNode removedAll(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetMultimapResult details, + final EqualityComparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractSetMultimapNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractSetMultimapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) + throw new NoSuchElementException(); + return AbstractSetMultimapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract int emptyArity(); + + // @Deprecated // split data / coll arity + // abstract boolean hasPayload(); + // + // @Deprecated // split data / coll arity + // abstract int payloadArity(); + + abstract boolean hasPayload(EitherSingletonOrCollection.Type type); + + // abstract int payloadArity(); + + abstract int payloadArity(EitherSingletonOrCollection.Type type); + + abstract K getSingletonKey(final int index); + + abstract V getSingletonValue(final int index); + + abstract K getCollectionKey(final int index); + + abstract Set.Immutable getCollectionValue(final int index); + + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + abstract int arity(); + + int size() { + final Iterator it = new SetMultimapKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactSetMultimapNode + extends AbstractSetMultimapNode { + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + static final int doubledMask(int keyHash, int shift) { + final int mask = mask(keyHash, shift); + return mask << 1; + } + + static final long doubledBitpos(final int doubledMask) { + return 1L << doubledMask; + } + + static final int pattern(long bitmap, int doubledMask) { + return (int) ((bitmap >>> doubledMask) & 0b11); + } + + // @Deprecated + // abstract int dataMap(); + // + // @Deprecated + // abstract int collMap(); + // + // @Deprecated + // abstract int nodeMap(); + + abstract long bitmap(); + + @Deprecated + @Override + int arity() { + // TODO: replace with 32 - arity(emptyMap) + // return arity(bitmap(), PATTERN_DATA_SINGLETON) + arity(bitmap(), PATTERN_DATA_COLLECTION) + + // arity(bitmap(), PATTERN_NODE); + + int[] arities = arities(bitmap()); + return Arrays.stream(arities).skip(1).sum(); + } + + static final int arity(long bitmap, int pattern) { + if (bitmap == 0) { + if (pattern == PATTERN_EMPTY) { + return 32; + } else { + return 0; + } + } else { + return Long.bitCount(filter(bitmap, pattern)); + } + } + + // TODO: Implement arity histogram over bitmap (with single for loop) that calculates offsets + static final int[] arities(final long bitmap) { + int[] arities = new int[4]; + + long shiftedBitmap = bitmap; + for (int i = 0; i < 32; i++) { + arities[(int) shiftedBitmap & 0b11]++; + shiftedBitmap = shiftedBitmap >>> 2; + } + + return arities; + } + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactSetMultimapNode getNode(final int index); + + boolean nodeInvariant() { + return true; + // boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + // boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + // boolean inv3 = + // (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + // boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + // + // boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + // && ((this.payloadArity() + this.nodeArity()) == this.arity()); + // + // return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + final long bitmap); + + abstract CompactSetMultimapNode copyAndSetSingletonValue( + final AtomicReference mutator, final long doubledBitpos, final V val); + + abstract CompactSetMultimapNode copyAndSetCollectionValue( + final AtomicReference mutator, final long doubledBitpos, + final Set.Immutable valColl); + + abstract CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final long doubledBitpos, final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndInsertSingleton( + final AtomicReference mutator, final long doubledBitpos, final K key, final V val); + + abstract CompactSetMultimapNode copyAndInsertCollection( + final AtomicReference mutator, final long doubledBitpos, final K key, + final Set.Immutable valColl); + + abstract CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + final AtomicReference mutator, final long doubledBitpos, final K key, + final Set.Immutable valColl); + + abstract CompactSetMultimapNode copyAndRemoveSingleton( + final AtomicReference mutator, final long doubledBitpos); + + abstract CompactSetMultimapNode copyAndRemoveSingleton( + final AtomicReference mutator, final long doubledBitpos, long updatedBitmap); + + /* + * Batch updated, necessary for removedAll. + */ + abstract CompactSetMultimapNode copyAndRemoveCollection( + final AtomicReference mutator, final long doubledBitpos); + + abstract CompactSetMultimapNode copyAndMigrateFromSingletonToNode( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndMigrateFromNodeToSingleton( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node); // node get's unwrapped inside method + + abstract CompactSetMultimapNode copyAndMigrateFromCollectionToNode( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndMigrateFromNodeToCollection( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node); // node get's unwrapped inside method + + abstract CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + final AtomicReference mutator, final long doubledBitpos, final K key, final V val); + + // TODO: fix hash collision support + static final CompactSetMultimapNode mergeTwoSingletonPairs(final K key0, + final V val0, final int keyHash0, final K key1, final V val1, final int keyHash1, + final int shift) { + assert !(key0.equals(key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode.of(keyHash0, key0, setOfNew(val0), key1, setOfNew(val1)); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_SINGLETON); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_SINGLETON); + + if (mask0 < mask1) { + return nodeOf(null, bitmap, new Object[] {key0, val0, key1, val1}); + } else { + return nodeOf(null, bitmap, new Object[] {key1, val1, key0, val0}); + } + } else { + final CompactSetMultimapNode node = mergeTwoSingletonPairs(key0, val0, keyHash0, key1, + val1, keyHash1, shift + BIT_PARTITION_SIZE); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf(null, bitmap, new Object[] {node}); + } + } + + // TODO: fix hash collision support + static final CompactSetMultimapNode mergeTwoCollectionPairs(final K key0, + final Set.Immutable valColl0, final int keyHash0, final K key1, + final Set.Immutable valColl1, final int keyHash1, final int shift) { + assert !(key0.equals(key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode.of(keyHash0, key0, valColl0, key1, valColl1); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_COLLECTION); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_COLLECTION); + + if (mask0 < mask1) { + return nodeOf(null, bitmap, new Object[] {key0, valColl0, key1, valColl1}); + } else { + return nodeOf(null, bitmap, new Object[] {key1, valColl1, key0, valColl0}); + } + } else { + final CompactSetMultimapNode node = mergeTwoCollectionPairs(key0, valColl0, keyHash0, + key1, valColl1, keyHash1, shift + BIT_PARTITION_SIZE); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf(null, bitmap, new Object[] {node}); + } + } + + // TODO: fix hash collision support + static final CompactSetMultimapNode mergeCollectionAndSingletonPairs(final K key0, + final Set.Immutable valColl0, final int keyHash0, final K key1, final V val1, + final int keyHash1, final int shift) { + assert !(key0.equals(key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode.of(keyHash0, key0, valColl0, key1, setOfNew(val1)); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_COLLECTION); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_SINGLETON); + + // singleton before collection + return nodeOf(null, bitmap, new Object[] {key1, val1, key0, valColl0}); + } else { + final CompactSetMultimapNode node = mergeCollectionAndSingletonPairs(key0, valColl0, + keyHash0, key1, val1, keyHash1, shift + BIT_PARTITION_SIZE); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf(null, bitmap, new Object[] {node}); + } + } + + static final CompactSetMultimapNode EMPTY_NODE; + + static { + EMPTY_NODE = new BitmapIndexedSetMultimapNode<>(null, 0L, new Object[] {}); + }; + + static final CompactSetMultimapNode nodeOf(final AtomicReference mutator, + final long bitmap, final Object[] nodes) { + return new BitmapIndexedSetMultimapNode<>(mutator, bitmap, nodes); + } + + @SuppressWarnings("unchecked") + static final CompactSetMultimapNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactSetMultimapNode nodeOf(AtomicReference mutator, + final long bitmap, final K key, final Set.Immutable valColl) { + return nodeOf(mutator, bitmap, new Object[] {key, valColl}); + } + + // static final int index(final int bitmap, final int bitpos) { + // return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + // } + // + // static final int index(final int bitmap, final int mask, final int bitpos) { + // return (bitmap == -1) ? mask : index(bitmap, bitpos); + // } + + @Deprecated + int dataIndex(final long doubledBitpos) { + return index(bitmap(), PATTERN_DATA_SINGLETON, doubledBitpos); + } + + @Deprecated + int collIndex(final long doubledBitpos) { + return index(bitmap(), PATTERN_DATA_COLLECTION, doubledBitpos); + } + + @Deprecated + int nodeIndex(final long doubledBitpos) { + return index(bitmap(), PATTERN_NODE, doubledBitpos); + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + return getSingletonKey(index).equals(key); + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + return getCollectionKey(index).equals(key); + } + default: + return false; + } + } + + boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented."); + } + + @Override + boolean containsTuple(final K key, final V val, final int keyHash, final int shift, EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + + final AbstractSetMultimapNode subNode = getNode(index); + return subNode.containsTuple(key, val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(index); + if (currentKey.equals(key)) { + + final V currentVal = getSingletonValue(index); + return currentVal.equals(val); + } + + return false; + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(index); + if (currentKey.equals(key)) { + + final Set.Immutable currentValColl = getCollectionValue(index); + return currentValColl.contains(val); + } + + return false; + } + default: + return false; + } + } + + @Override + Optional> findByKey(final K key, final int keyHash, final int shift, EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + + final AbstractSetMultimapNode subNode = getNode(index); + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(index); + if (currentKey.equals(key)) { + + final V currentVal = getSingletonValue(index); + return Optional.of(setOfNew(currentVal)); + } + + return Optional.empty(); + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(index); + if (currentKey.equals(key)) { + + final Set.Immutable currentValColl = getCollectionValue(index); + return Optional.of(currentValColl); + } + + return Optional.empty(); + } + default: + return Optional.empty(); + } + } + + Optional> findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + throw new UnsupportedOperationException("Not yet implemented."); + } + + @Override + CompactSetMultimapNode inserted(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.inserted(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (currentKey.equals(key)) { + final V currentVal = getSingletonValue(dataIndex); + + if (currentVal.equals(val)) { + return this; + } else { + // migrate from singleton to collection + final Set.Immutable valColl = setOfNew(currentVal, val); + + details.modified(); + return copyAndMigrateFromSingletonToCollection(mutator, doubledBitpos, currentKey, + valColl); + } + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (currentCollKey.equals(key)) { + final Set.Immutable currentCollVal = getCollectionValue(collIndex); + + if (currentCollVal.contains(val)) { + return this; + } else { + // add new mapping + final Set.Immutable newCollVal = currentCollVal.insert(val); + + details.modified(); + return copyAndSetCollectionValue(mutator, doubledBitpos, newCollVal); + } + } else { + // prefix-collision (case: collection x singleton) + final Set.Immutable currentValNode = getCollectionValue(collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertSingleton(mutator, doubledBitpos, key, val); + } + } + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (currentKey.equals(key)) { + final V currentVal = getSingletonValue(dataIndex); + + // update singleton value + details.updated(currentVal); + return copyAndSetSingletonValue(mutator, doubledBitpos, val); + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (currentCollKey.equals(key)) { + final Set.Immutable currentCollVal = getCollectionValue(collIndex); + + // migrate from collection to singleton + details.updated(currentCollVal); + return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, currentCollKey, + val); + } else { + // prefix-collision (case: collection x singleton) + final Set.Immutable currentValNode = getCollectionValue(collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertSingleton(mutator, doubledBitpos, key, val); + } + } + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final Set valColl, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.updated(mutator, key, valColl, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (currentKey.equals(key)) { + final V currentVal = getSingletonValue(dataIndex); + + // migrate from singleton to collection + details.updated(currentVal); + return copyAndMigrateFromSingletonToCollection(mutator, doubledBitpos, currentKey, + valColl.asImmutable()); + // + // + // // update singleton value + // details.updated(currentVal); + // return copyAndSetSingletonValue(mutator, doubledBitpos, valColl); + } else { + // prefix-collision (case: collection x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs(key, + valColl.asImmutable(), keyHash, currentKey, currentVal, + transformHashCode(currentKey.hashCode()), shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, subNodeNew); + + // // prefix-collision (case: singleton x singleton) + // final V currentVal = getSingletonValue(dataIndex); + // + // final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + // currentVal, transformHashCode(currentKey.hashCode()), key, valColl, keyHash, + // shift + BIT_PARTITION_SIZE); + // + // details.modified(); + // return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (currentCollKey.equals(key)) { + final Set.Immutable currentCollVal = getCollectionValue(collIndex); + + // update collection value + details.updated(currentCollVal); + return copyAndSetCollectionValue(mutator, doubledBitpos, valColl.asImmutable()); + + // // migrate from collection to singleton + // details.updated(currentCollVal); + // return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, + // currentCollKey, + // valColl); + } else { + // prefix-collision (case: collection x collection) + final Set.Immutable currentValNode = getCollectionValue(collIndex); + final CompactSetMultimapNode subNodeNew = mergeTwoCollectionPairs(currentCollKey, + currentValNode.asImmutable(), transformHashCode(currentCollKey.hashCode()), key, + valColl.asImmutable(), keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, subNodeNew); + + // // prefix-collision (case: collection x singleton) + // final Set.Immutable currentValNode = getCollectionValue(collIndex); + // final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + // currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + // valColl, keyHash, shift + BIT_PARTITION_SIZE); + // + // details.modified(); + // return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertCollection(mutator, doubledBitpos, key, valColl.asImmutable()); + } + } + } + + @Override + CompactSetMultimapNode removed(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.removed(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (slotArity() == 0) { + if (shift == 0) { + // singleton remaining + final long doubledBitposAtShift0 = doubledBitpos(bitpos(doubledMask(keyHash, 0))); + + final long updatedBitmapAtShift0 = + setBitPattern(doubledBitposAtShift0, subNodeNew.patternOfSingleton()); + + return subNodeNew.copyAndUpdateBitmaps(mutator, updatedBitmapAtShift0); + } else { + // escalate (singleton or empty) result + return subNodeNew; + } + } else { + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + } + + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (currentKey.equals(key)) { + + final V currentVal = getSingletonValue(dataIndex); + if (currentVal.equals(val)) { + + // remove mapping + details.updated(val); + return copyAndRemoveSingleton(mutator, doubledBitpos); + } else { + return this; + } + } else { + return this; + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(collIndex); + if (currentKey.equals(key)) { + + final Set.Immutable currentValColl = getCollectionValue(collIndex); + if (currentValColl.contains(val)) { + + // remove mapping + details.updated(val); + + final Set.Immutable newValColl = currentValColl.remove(val); + + if (newValColl.size() == 1) { + // TODO: investigate options for unboxing singleton collections + V remainingVal = newValColl.iterator().next(); + return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, key, + remainingVal); + } else { + return copyAndSetCollectionValue(mutator, doubledBitpos, newValColl); + } + } else { + return this; + } + } else { + return this; + } + } + default: + return this; + } + } + + final static boolean hasSingleNode(int[] arities) { + return arities[PATTERN_EMPTY] == 31 && arities[PATTERN_NODE] == 1; + } + + final static boolean hasTwoPayloads(int[] arities) { + return arities[PATTERN_EMPTY] == 30 && arities[PATTERN_NODE] == 0; + } + + enum State { + EMPTY, NODE, PAYLOAD, PAYLOAD_RARE + } + + static final State toState(final int pattern) { + // final State[] states = {State.EMPTY, State.NODE, State.PAYLOAD, State.PAYLOAD_RARE}; + // return states[pattern]; + + switch (pattern) { + case PATTERN_EMPTY: + return State.EMPTY; + case PATTERN_NODE: + return State.NODE; + case PATTERN_DATA_SINGLETON: + return State.PAYLOAD; + default: + return State.PAYLOAD_RARE; + } + } + + @Override + CompactSetMultimapNode removedAll(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetMultimapResult details, EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.removedAll(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (slotArity() == 1) { + if (shift == 0) { + // singleton remaining + final long doubledBitposAtShift0 = doubledBitpos(bitpos(doubledMask(keyHash, 0))); + + final long updatedBitmapAtShift0 = + setBitPattern(doubledBitposAtShift0, subNodeNew.patternOfSingleton()); + + return subNodeNew.copyAndUpdateBitmaps(mutator, updatedBitmapAtShift0); + } else { + // escalate (singleton or empty) result + return subNodeNew; + } + } else { + // // inline value (move to front) + // final State subNodeState = subNodeNew.stateOfSingleton(); + // + //// switch (subNodeState) { + //// case EMPTY: + //// case NODE: + //// case PAYLOAD: + //// return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + //// case PAYLOAD_RARE: + //// return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + //// } + // + // if (subNodeState == State.PAYLOAD) { + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // } else { + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // } + + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + } + + // // inline value (move to front) + // final int subNodePattern = subNodeNew.patternOfSingleton(); + // + // if (subNodePattern == PATTERN_DATA_SINGLETON) { + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // } else { + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // } + + // switch (subNodePattern) { + // case PATTERN_DATA_SINGLETON: + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // case PATTERN_DATA_COLLECTION: + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // default: + // return null; + // } + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (currentKey.equals(key)) { + + final V currentVal = getSingletonValue(dataIndex); + + details.updated(currentVal); + return copyAndRemoveSingleton(mutator, doubledBitpos); + } else { + return this; + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(collIndex); + if (currentKey.equals(key)) { + + final Set.Immutable currentValColl = getCollectionValue(collIndex); + + details.updated(currentValColl); + return copyAndRemoveCollection(mutator, doubledBitpos); + } else { + return this; + } + } + default: + return this; + } + } + + abstract int patternOfSingleton(); + + @Deprecated + abstract EitherSingletonOrCollection.Type typeOfSingleton(); + + @Deprecated + abstract State stateOfSingleton(); + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + long bitmap = this.bitmap(); + + int[] arities = arities(bitmap); + + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < arities[PATTERN_DATA_SINGLETON]; i++) { + final byte pos = -1; // TODO: recoverMask(dataMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getSingletonKey(i)), + Objects.hashCode(getSingletonValue(i)))); + + if (!((i + 1) == arities[PATTERN_DATA_SINGLETON])) { + bldr.append(", "); + } + } + + if (arities[PATTERN_DATA_SINGLETON] > 0 && arities[PATTERN_DATA_COLLECTION] > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arities[PATTERN_DATA_COLLECTION]; i++) { + final byte pos = -1; // TODO: recoverMask(collMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getCollectionKey(i)), + Objects.hashCode(getCollectionValue(i)))); + + if (!((i + 1) == arities[PATTERN_DATA_COLLECTION])) { + bldr.append(", "); + } + } + + if (arities[PATTERN_DATA_COLLECTION] > 0 && arities[PATTERN_NODE] > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arities[PATTERN_NODE]; i++) { + final byte pos = -1; // TODO: recoverMask(nodeMap, (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == arities[PATTERN_NODE])) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedSetMultimapNode + extends CompactSetMultimapNode { + + private final long bitmap; + + CompactMixedSetMultimapNode(final AtomicReference mutator, final long bitmap) { + this.bitmap = bitmap; + } + + @Override + public long bitmap() { + return bitmap; + } + + // @Override + // int dataMap() { + // return rawMap2() ^ collMap(); + // } + // + // @Override + // int collMap() { + // return rawMap1() & rawMap2(); + // } + // + // @Override + // int nodeMap() { + // return rawMap1() ^ collMap(); + // } + + } + + private static final class BitmapIndexedSetMultimapNode + extends CompactMixedSetMultimapNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedSetMultimapNode(final AtomicReference mutator, final long bitmap, + final Object[] nodes) { + super(mutator, bitmap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + int[] arities = arities(bitmap); + + assert (TUPLE_LENGTH * arities[PATTERN_DATA_SINGLETON] + + TUPLE_LENGTH * arities[PATTERN_DATA_COLLECTION] + + arities[PATTERN_NODE] == nodes.length); + + for (int i = 0; i < arities[PATTERN_DATA_SINGLETON]; i++) { + int offset = i * TUPLE_LENGTH; + + assert ((nodes[offset + 0] instanceof Set.Immutable) == false); + assert ((nodes[offset + 1] instanceof Set.Immutable) == false); + + assert ((nodes[offset + 0] instanceof CompactSetMultimapNode) == false); + assert ((nodes[offset + 1] instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arities[PATTERN_DATA_COLLECTION]; i++) { + int offset = (i + arities[PATTERN_DATA_SINGLETON]) * TUPLE_LENGTH; + + assert ((nodes[offset + 0] instanceof Set.Immutable) == false); + assert ((nodes[offset + 1] instanceof Set.Immutable) == true); + + assert ((nodes[offset + 0] instanceof CompactSetMultimapNode) == false); + assert ((nodes[offset + 1] instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arities[PATTERN_NODE]; i++) { + int offset = + (arities[PATTERN_DATA_SINGLETON] + arities[PATTERN_DATA_COLLECTION]) * TUPLE_LENGTH; + + assert ((nodes[offset + i] instanceof Set.Immutable) == false); + + assert ((nodes[offset + i] instanceof CompactSetMultimapNode) == true); + } + } + + assert nodeInvariant(); + } + + @SuppressWarnings("unchecked") + @Override + K getSingletonKey(final int index) { + return (K) nodes[TUPLE_LENGTH * index]; + } + + @SuppressWarnings("unchecked") + @Override + V getSingletonValue(int index) { + return (V) nodes[TUPLE_LENGTH * index + 1]; + } + + @SuppressWarnings("unchecked") + @Override + K getCollectionKey(int index) { + // TODO: improve on offset calculation (caching it, etc) + int offset = TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + index); + return (K) nodes[offset]; + } + + @SuppressWarnings("unchecked") + @Override + Set.Immutable getCollectionValue(final int index) { + // TODO: improve on offset calculation (caching it, etc) + int offset = TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + index) + 1; + return (Set.Immutable) nodes[offset]; + } + + @SuppressWarnings("unchecked") + @Override + CompactSetMultimapNode getNode(final int index) { + return (CompactSetMultimapNode) nodes[nodes.length - 1 - index]; + } + + // @Override + // boolean hasPayload() { + // return rawMap2() != 0; + // } + // + // @Override + // int payloadArity() { + // return java.lang.Integer.bitCount(rawMap2()); + // } + + @Override + int emptyArity() { + return arity(bitmap(), PATTERN_EMPTY); + } + + boolean hasPayload(EitherSingletonOrCollection.Type type) { + return payloadArity(type) != 0; + } + + @Override + int payloadArity(EitherSingletonOrCollection.Type type) { + // int[] arities = arities(bitmap()); + // return arities[PATTERN_NODE]; + + if (type == Type.SINGLETON) { + // return arities[PATTERN_DATA_SINGLETON]; + return arity(bitmap(), PATTERN_DATA_SINGLETON); + } else { + // return arities[PATTERN_DATA_COLLECTION]; + return arity(bitmap(), PATTERN_DATA_COLLECTION); + } + } + + @Override + boolean hasNodes() { + return nodeArity() != 0; + } + + @Override + int nodeArity() { + // int[] arities = arities(bitmap()); + // return arities[PATTERN_NODE]; + return arity(bitmap(), PATTERN_NODE); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = (int) (prime * result + (bitmap())); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedSetMultimapNode that = (BitmapIndexedSetMultimapNode) other; + if (bitmap() != that.bitmap()) { + return false; + } + if (!Arrays.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + + // switch (slotArity()) { + // case 0: + // return SIZE_EMPTY; + // case 1: + // return SIZE_MORE_THAN_ONE; // works for maps only: must be subnode; patternOfSingleton(); + // case 2: + // return arity(bitmap(), PATTERN_NODE) == 0 ? SIZE_ONE : SIZE_MORE_THAN_ONE; + // default: + // return SIZE_MORE_THAN_ONE; + // } + + // if (this.nodeArity() == 0) { + // switch (this.payloadArity()) { + // case 0: + // return SIZE_EMPTY; + // case 1: + // return SIZE_ONE; + // default: + // return SIZE_MORE_THAN_ONE; + // } + // } else { + // return SIZE_MORE_THAN_ONE; + // } + + // int[] arities = arities(bitmap()); + // + // int nodeArity = arities[PATTERN_NODE]; + // int emptyArity = arities[PATTERN_EMPTY]; + + final long bitmap = this.bitmap(); + + int nodeArity = arity(bitmap, PATTERN_NODE); + int emptyArity = arity(bitmap, PATTERN_EMPTY); + + // int aritySingleton = arity(bitmap, PATTERN_DATA_SINGLETON); + // int arityCollection = arity(bitmap, PATTERN_DATA_COLLECTION); + + if (nodeArity > 0) { + return SIZE_MORE_THAN_ONE; + } else { + switch (emptyArity) { + case 32: + return SIZE_EMPTY; + case 31: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } + + // if (this.nodeArity() == 0) { + // switch (arity(bitmap(), PATTERN_DATA_SINGLETON) + // + arity(bitmap(), PATTERN_DATA_COLLECTION)) { + // case 0: + // return SIZE_EMPTY; + // case 1: + // return SIZE_ONE; + // default: + // return SIZE_MORE_THAN_ONE; + // } + // } else { + // return SIZE_MORE_THAN_ONE; + // } + } + + @Override + CompactSetMultimapNode copyAndSetSingletonValue(final AtomicReference mutator, + final long doubledBitpos, final V val) { + + final int idx = TUPLE_LENGTH * dataIndex(doubledBitpos) + 1; + final CompactSetMultimapNode updatedNode = copyAndSetXxxValue(mutator, idx, val); + + return updatedNode; + } + + @Override + CompactSetMultimapNode copyAndSetCollectionValue(final AtomicReference mutator, + final long doubledBitpos, final Set.Immutable valColl) { + + final int idx = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)) + 1; + final CompactSetMultimapNode updatedNode = copyAndSetXxxValue(mutator, idx, valColl); + + return updatedNode; + } + + private CompactSetMultimapNode copyAndSetXxxValue(final AtomicReference mutator, + final int idx, final Object newValue) { + final CompactSetMultimapNode updatedNode; + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = newValue; + updatedNode = this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = newValue; + + updatedNode = nodeOf(mutator, bitmap(), dst); + } + return updatedNode; + } + + @Override + CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final long doubledBitpos, final CompactSetMultimapNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(doubledBitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, bitmap(), dst); + } + } + + @Override + CompactSetMultimapNode copyAndInsertSingleton(final AtomicReference mutator, + final long doubledBitpos, final K key, final V val) { + final int idx = TUPLE_LENGTH * dataIndex(doubledBitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = val; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_DATA_SINGLETON); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndInsertCollection(final AtomicReference mutator, + final long doubledBitpos, final K key, final Set.Immutable valColl) { + final int idx = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = valColl; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_DATA_COLLECTION); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + AtomicReference mutator, long doubledBitpos, K key, Set.Immutable valColl) { + + final int idxOld = TUPLE_LENGTH * dataIndex(doubledBitpos); + final int idxNew = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) - 1 + collIndex(doubledBitpos)); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = key; + dst[idxNew + 1] = valColl; + System.arraycopy(src, idxNew + 2, dst, idxNew + 2, src.length - idxNew - 2); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_DATA_COLLECTION); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + AtomicReference mutator, long doubledBitpos, K key, V val) { + + // TODO: does not support src == dst yet for shifting + + final int idxOld = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + final int idxNew = TUPLE_LENGTH * dataIndex(doubledBitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' + assert idxNew <= idxOld; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = key; + dst[idxNew + 1] = val; + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 2, dst, idxOld + 2, src.length - idxOld - 2); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_DATA_SINGLETON); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(final AtomicReference mutator, + final long doubledBitpos) { + final int idx = TUPLE_LENGTH * dataIndex(doubledBitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_EMPTY); + return nodeOf(mutator, updatedBitmap, dst); + } + + // TODO: remove code duplication and merge with above + @Override + CompactSetMultimapNode copyAndRemoveSingleton(final AtomicReference mutator, + final long doubledBitpos, long updatedBitmap) { + final int idx = TUPLE_LENGTH * dataIndex(doubledBitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndRemoveCollection(final AtomicReference mutator, + final long doubledBitpos) { + final int idx = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_EMPTY); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToNode( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(doubledBitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(doubledBitpos); + + final Object[] dst = copyAndMigrateFromXxxToNode(idxOld, idxNew, node); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_NODE); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToNode(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + + final int idxOld = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(doubledBitpos); + + final Object[] dst = copyAndMigrateFromXxxToNode(idxOld, idxNew, node); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_NODE); + return nodeOf(mutator, updatedBitmap, dst); + } + + private Object[] copyAndMigrateFromXxxToNode(final int idxOld, final int idxNew, + final CompactSetMultimapNode node) { + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2 + 1]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 2, dst, idxNew + 1, src.length - idxNew - 2); + + return dst; + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(doubledBitpos); + final int idxNew = TUPLE_LENGTH * dataIndex(doubledBitpos); + + Object keyToInline = node.getSingletonKey(0); + Object valToInline = node.getSingletonValue(0); + + final Object[] dst = copyAndMigrateFromNodeToXxx(idxOld, idxNew, keyToInline, valToInline); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_DATA_COLLECTION); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToCollection(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(doubledBitpos); + final int idxNew = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + + Object keyToInline = node.getCollectionKey(0); + Object valToInline = node.getCollectionValue(0); + + final Object[] dst = copyAndMigrateFromNodeToXxx(idxOld, idxNew, keyToInline, valToInline); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_DATA_COLLECTION); + return nodeOf(mutator, updatedBitmap, dst); + } + + private Object[] copyAndMigrateFromNodeToXxx(final int idxOld, final int idxNew, + Object keyToInline, Object valToInline) { + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 2]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = keyToInline; + dst[idxNew + 1] = valToInline; + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 2, src.length - idxOld - 1); + + return dst; + } + + @Override + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + final long bitmap) { + return nodeOf(mutator, bitmap, nodes); + } + + @Override + int patternOfSingleton() { + assert this.sizePredicate() == SIZE_ONE; + + long bitmap = this.bitmap(); + + final int doubledMask = Long.numberOfTrailingZeros(bitmap) / 2 * 2; + final int pattern = pattern(bitmap, doubledMask); + + return pattern; + } + + @Override + State stateOfSingleton() { + assert this.sizePredicate() == SIZE_ONE; + + long bitmap = this.bitmap(); + + final int doubledMask = Long.numberOfTrailingZeros(bitmap) / 2 * 2; + final int pattern = pattern(bitmap, doubledMask); + + return toState(pattern); + } + + @Deprecated + @Override + EitherSingletonOrCollection.Type typeOfSingleton() { + final int pattern = patternOfSingleton(); + + if (pattern == PATTERN_DATA_SINGLETON) { + return EitherSingletonOrCollection.Type.SINGLETON; + } else { + return EitherSingletonOrCollection.Type.COLLECTION; + } + } + + } + + private static abstract class AbstractHashCollisionNode + extends CompactSetMultimapNode { + + static final > AbstractHashCollisionNode of( + final int hash, final K key0, final VS valColl0, final K key1, final VS valColl1) { + return new HashCollisionNode<>(hash, key0, valColl0, key1, valColl1); + } + + private static final RuntimeException UOE_BOILERPLATE = new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + private static final Supplier UOE_FACTORY = + () -> new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + @Override + public long bitmap() { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndSetSingletonValue(AtomicReference mutator, + long doubledBitpos, V val) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndSetCollectionValue(AtomicReference mutator, + long doubledBitpos, Set.Immutable valColl) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndSetNode(AtomicReference mutator, long doubledBitpos, + CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndInsertSingleton(AtomicReference mutator, + long doubledBitpos, K key, V val) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + AtomicReference mutator, long doubledBitpos, K key, Set.Immutable valColl) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(AtomicReference mutator, + long doubledBitpos) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveCollection(AtomicReference mutator, + long doubledBitpos) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToNode(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToNode(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToCollection(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + long bitmap) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndInsertCollection(AtomicReference mutator, + long doubledBitpos, K key, Set.Immutable valColl) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(AtomicReference mutator, + long doubledBitpos, long updatedBitmap) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + AtomicReference mutator, long doubledBitpos, K key, V val) { + throw UOE_FACTORY.get(); + } + + @Override + int emptyArity() { + throw UOE_FACTORY.get(); + } + + @Override + Type typeOfSingleton() { + throw UOE_FACTORY.get(); + } + + @Override + int patternOfSingleton() { + throw UOE_FACTORY.get(); + } + } + + private static final class HashCollisionNode extends AbstractHashCollisionNode { + + private final int hash; + private final List>> collisionContent; + + HashCollisionNode(final int hash, final K key0, final Set.Immutable valColl0, final K key1, + final Set.Immutable valColl1) { + this(hash, Arrays.asList(entryOf(key0, valColl0), entryOf(key1, valColl1))); + } + + HashCollisionNode(final int hash, final List>> collisionContent) { + this.hash = hash; + this.collisionContent = collisionContent; + } + + private static final RuntimeException UOE = new UnsupportedOperationException(); + + private static final Supplier UOE_NOT_YET_IMPLEMENTED_FACTORY = + () -> new UnsupportedOperationException("Not yet implemented @ HashCollisionNode."); + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + CompactSetMultimapNode getNode(int index) { + throw UOE; + } + + @Override + boolean hasPayload(EitherSingletonOrCollection.Type type) { + switch (type) { + case SINGLETON: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).findAny() + .isPresent(); + case COLLECTION: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).findAny() + .isPresent(); + } + throw new RuntimeException(); + } + + @Override + int payloadArity(EitherSingletonOrCollection.Type type) { + switch (type) { + case SINGLETON: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).count(); + case COLLECTION: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).count(); + } + throw new RuntimeException(); + } + + @Override + K getSingletonKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getKey(); + } + + @Override + V getSingletonValue(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getValue().stream().findAny().get(); + } + + @Override + K getCollectionKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getKey(); + } + + @Override + Set.Immutable getCollectionValue(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getValue(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return collisionContent.size() * 2; + } + + @Override + Object getSlot(int index) { + if (index % 2 == 0) { + return collisionContent.get(index / 2).getKey(); + } else { + return collisionContent.get(index / 2).getValue(); + } + } + + @Override + boolean containsKey(K key, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny() + .isPresent(); + } + + @Override + boolean containsTuple(K key, V val, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) && entry.getValue().contains(val)) + .findAny().isPresent(); + } + + @Override + Optional> findByKey(K key, int keyHash, int shift, + EqualityComparator cmp) { + throw UOE_NOT_YET_IMPLEMENTED_FACTORY.get(); + } + + @Override + CompactSetMultimapNode inserted(AtomicReference mutator, K key, V val, + int keyHash, int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + Set.Immutable values = optionalTuple.get().getValue(); + + if (values.contains(val)) { + // contains key and value + details.unchanged(); + return this; + + } else { + // contains key but not value + + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + Set.Immutable updatedValues = values.insert(val); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + // TODO does not check that remainder is unmodified + assert updatedCollisionContent.size() == collisionContent.size(); + assert updatedCollisionContent.contains(optionalTuple.get()) == false; + // assert updatedCollisionContent.contains(entryOf(key, values.__insertEquivalent(val, + // cmp.toComparator()))); + assert updatedCollisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) && entry.getValue().contains(val)) + .findAny().isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder().add(entryOf(key, setOfNew(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + assert updatedCollisionContent.size() == collisionContent.size() + 1; + assert updatedCollisionContent.containsAll(collisionContent); + // assert updatedCollisionContent.contains(entryOf(key, setOf(val))); + assert updatedCollisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey()) + && Objects.equals(setOf(val), entry.getValue())).findAny().isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode updated(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key -> replace val anyways + + Set.Immutable values = optionalTuple.get().getValue(); + + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + Set.Immutable updatedValues = values.insert(val); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + if (values.size() == 1) { + details.updated(values.stream().findAny().get()); // unbox singleton + } else { + details.updated(values); + } + + return new HashCollisionNode(hash, updatedCollisionContent); + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder().add(entryOf(key, setOfNew(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode removed(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + Set.Immutable values = optionalTuple.get().getValue(); + + if (values.contains(val)) { + // contains key and value -> remove mapping + + final List>> updatedCollisionContent; + + if (values.size() == 1) { + updatedCollisionContent = collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry != optionalTuple.get()) + .collect(Collectors.toList()); + } else { + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + Set.Immutable updatedValues = values.remove(val); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + } + + details.updated(val); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + details.unchanged(); + return this; + } + + @Override + State stateOfSingleton() { + return null; + } + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueSingletonCursor; + protected int currentValueSingletonLength; + protected int currentValueCollectionCursor; + protected int currentValueCollectionLength; + protected AbstractSetMultimapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + @SuppressWarnings("unchecked") + AbstractSetMultimapNode[] nodes = new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapIterator(AbstractSetMultimapNode rootNode) { + int nodeArity = rootNode.nodeArity(); + if (nodeArity != 0) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = nodeArity; + } + + int emptyArity = rootNode.emptyArity(); + if (emptyArity + nodeArity < 32) { + currentValueNode = rootNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = rootNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = rootNode.payloadArity(COLLECTION); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractSetMultimapNode nextNode = + nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + int nodeArity = nextNode.nodeArity(); + if (nodeArity != 0) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nodeArity; + } + + // int emptyArity = nextNode.emptyArity(); + // if (emptyArity + nodeArity < 32) { + if (nextNode.hasPayload(SINGLETON) || nextNode.hasPayload(COLLECTION)) { + // if (payloadAritySingleton != 0 || payloadArityCollection != 0) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = nextNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = nextNode.payloadArity(Type.COLLECTION); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueSingletonCursor < currentValueSingletonLength + || currentValueCollectionCursor < currentValueCollectionLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetMultimapKeyIterator extends AbstractSetMultimapIterator + implements Iterator { + + SetMultimapKeyIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return currentValueNode.getSingletonKey(currentValueSingletonCursor++); + } else { + return currentValueNode.getCollectionKey(currentValueCollectionCursor++); + } + } + } + + } + + protected static class SetMultimapValueIterator extends AbstractSetMultimapIterator + implements Iterator> { + + SetMultimapValueIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public Set.Immutable next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return setOfNew(currentValueNode.getSingletonValue(currentValueSingletonCursor++)); + } else { + return currentValueNode.getCollectionValue(currentValueCollectionCursor++); + } + } + } + + } + + protected static class SetMultimapNativeTupleIterator + extends AbstractSetMultimapIterator implements Iterator> { + + SetMultimapNativeTupleIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + final K currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + final Object currentValue = + currentValueNode.getSingletonValue(currentValueSingletonCursor); + currentValueSingletonCursor++; + + return AbstractSpecialisedImmutableMap.entryOf(currentKey, currentValue); + } else { + final K currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + final Object currentValue = + currentValueNode.getCollectionValue(currentValueCollectionCursor); + currentValueCollectionCursor++; + + return AbstractSpecialisedImmutableMap.entryOf(currentKey, currentValue); + } + } + } + + } + + protected static class SetMultimapTupleIterator extends AbstractSetMultimapIterator + implements Iterator { + + final BiFunction tupleOf; + + K currentKey = null; + V currentValue = null; + Iterator currentSetIterator = Collections.emptyIterator(); + + SetMultimapTupleIterator(AbstractSetMultimapNode rootNode, + final BiFunction tupleOf) { + super(rootNode); + this.tupleOf = tupleOf; + } + + @Override + public boolean hasNext() { + if (currentSetIterator.hasNext()) { + return true; + } else { + if (super.hasNext()) { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + currentSetIterator = Collections + .singleton(currentValueNode.getSingletonValue(currentValueSingletonCursor)) + .iterator(); + currentValueSingletonCursor++; + } else { + currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + currentSetIterator = + currentValueNode.getCollectionValue(currentValueCollectionCursor).iterator(); + currentValueCollectionCursor++; + } + + return true; + } else { + return false; + } + } + } + + @Override + public T next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + currentValue = currentSetIterator.next(); + return tupleOf.apply(currentKey, currentValue); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieSetMultimapNodeIterator + implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieSetMultimapNodeIterator(AbstractSetMultimapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractSetMultimapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieSetMultimap implements SetMultimap.Transient { + + private final EqualityComparator cmp; + + final private AtomicReference mutator; + private AbstractSetMultimapNode rootNode; + private int cachedHashCode; + private long cachedSize; + + TransientTrieSetMultimap(TrieSetMultimap TrieSetMultimap) { + this.cmp = TrieSetMultimap.cmp; + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = TrieSetMultimap.rootNode; + this.cachedHashCode = TrieSetMultimap.cachedHashCode; + this.cachedSize = TrieSetMultimap.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(cachedHashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final long targetSize) { + int hash = 0; + long size = 0; + + for (Map.Entry entry : this) { + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash ^= key.hashCode(); + hash ^= val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean contains(final K key) { + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } + + @Override + public boolean contains(final K key, final V val) { + return rootNode.containsTuple(key, val, transformHashCode(key.hashCode()), 0, cmp); + } + + // @Override + // public boolean containsEntryEquivalent(final Object o0, final Object o1, + // final Comparator cmp) { + // throw new UnsupportedOperationException("Not yet implemented."); + // } + + @Override + public Optional> apply(K key) { + return rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + } + + // @Override + // public Set.Immutable get(final Object o) { + // try { + // @SuppressWarnings("unchecked") + // final K key = (K) o; + // final Optional> result = + // rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + // + // if (result.isPresent()) { + // return result.get(); + // } else { + // return null; + // } + // } catch (ClassCastException unused) { + // return null; + // } + // } + // + // @Override + // public Set.Immutable getEquivalent(final Object o, final Comparator cmp) { + // throw new UnsupportedOperationException("Not yet implemented."); + // } + + @Override + public boolean put(K key, V val) { + throw new UnsupportedOperationException("Not yet implemented."); + } + + @Override + public boolean put(K key, Set values) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + // TODO: canoicalize for singleton + if (values.size() == 1) { + throw new IllegalStateException(); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.updated(null, key, values, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = values.hashCode(); + + rootNode = newRootNode; + cachedSize = cachedSize - 1 + values.size(); + + // int tmp = (values.size() % 2 == 1) ? 0 : keyHash; + // hashCode = hashCode ^ valHashOld ^ valHashNew ^ tmp; + + if ((1 + values.size()) % 2 == 0) { + // keyHash count is even + cachedHashCode = cachedHashCode ^ valHashOld ^ valHashNew; + } else { + // keyHash count is odd + cachedHashCode = cachedHashCode ^ valHashOld ^ valHashNew ^ keyHash; + } + + // return setOfNew(details.getReplacedValue()); + + if (DEBUG) { + assert checkHashCodeAndSize(cachedHashCode, cachedSize); + } + + return true; + } else { + final int valHashOld = details.getReplacedCollection().hashCode(); + final int valHashNew = values.hashCode(); + + rootNode = newRootNode; + cachedSize = cachedSize - details.getReplacedCollection().size() + values.size(); + + // int tmp = (values.size() % 2 == 1) ? 0 : keyHash; + // hashCode = hashCode ^ valHashOld ^ valHashNew ^ tmp; + + if ((details.getReplacedCollection().size() + values.size()) % 2 == 0) { + // keyHash count is even + cachedHashCode = cachedHashCode ^ valHashOld ^ valHashNew; + } else { + // keyHash count is odd + cachedHashCode = cachedHashCode ^ valHashOld ^ valHashNew ^ keyHash; + } + + // TODO: likely expensive + // TODO: first calculate difference before swapping + // return values.asImmutable().removeAll(details.getReplacedCollection()); + + if (DEBUG) { + assert checkHashCodeAndSize(cachedHashCode, cachedSize); + } + + return true; + } + } + + final int valHashOld = 0; + final int valHashNew = values.hashCode(); + + rootNode = newRootNode; + cachedSize = cachedSize + values.size(); + + if ((values.size()) % 2 == 0) { + // keyHash count is even + cachedHashCode = cachedHashCode ^ valHashOld ^ valHashNew; + } else { + // keyHash count is odd + cachedHashCode = cachedHashCode ^ valHashOld ^ valHashNew ^ keyHash; + } + + // return setOfNew(); + + if (DEBUG) { + assert checkHashCodeAndSize(cachedHashCode, cachedSize); + } + + return true; + } + + // return setOfNew(); + return false; + } + + @Override + public boolean insert(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + cachedHashCode ^= (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(cachedHashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(cachedHashCode, cachedSize); + } + return false; + } + + @Override + public boolean insert(final K key, final Set values) { + throw new UnsupportedOperationException("Not yet implemented."); + } + + @Override + public boolean remove(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + cachedHashCode = cachedHashCode ^ (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(cachedHashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(cachedHashCode, cachedSize); + } + + return false; + } + + @Override + public boolean remove(final K key) { + throw new UnsupportedOperationException("Not yet implemented."); + } + + @Override + public boolean union(final SetMultimap setMultimap) { + boolean modified = false; + + /* TODO: use more efficient Iterator> */ + for (Map.Entry entry : setMultimap) { + modified |= this.insert(entry.getKey(), entry.getValue()); + } + + return modified; + } + + @Override + public boolean intersect(final SetMultimap setMultimap) { + throw new UnsupportedOperationException("Not yet implemented."); + } + + @Override + public boolean complement(final SetMultimap setMultimap) { + throw new UnsupportedOperationException("Not yet implemented."); + } + + @Override + public long size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator> iterator() { + return new TransientSetMultimapTupleIterator<>(this, + AbstractSpecialisedImmutableMap::entryOf); + } + + // TODO: make transient version of this iterator + @Override + public Iterator> nativeEntryIterator() { + return new SetMultimapNativeTupleIterator<>(rootNode); + } + + // @Override + // public Iterator keyIterator() { + // return new TransientSetMultimapKeyIterator<>(this); + // } + // + // @Override + // public Iterator valueIterator() { + // return valueCollectionsStream().flatMap(Set::stream).iterator(); + // } + // + // @Override + // public Iterator> entryIterator() { + // return new TransientSetMultimapTupleIterator<>(this, + // AbstractSpecialisedImmutableMap::entryOf); + // } + // + // @Override + // public Iterator tupleIterator(final BiFunction tupleOf) { + // return new TransientSetMultimapTupleIterator<>(this, tupleOf); + // } + // + // private Spliterator> valueCollectionsSpliterator() { + // /* + // * TODO: specialize between mutable / immutable ({@see Spliterator.IMMUTABLE}) + // */ + // int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + // return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + // characteristics); + // } + // + // private Stream> valueCollectionsStream() { + // boolean isParallel = false; + // return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + // } + + public static class TransientSetMultimapKeyIterator extends SetMultimapKeyIterator { + final TransientTrieSetMultimap collection; + K lastKey; + + public TransientSetMultimapKeyIterator(final TransientTrieSetMultimap collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapValueIterator + extends SetMultimapValueIterator { + final TransientTrieSetMultimap collection; + + public TransientSetMultimapValueIterator(final TransientTrieSetMultimap collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public Set.Immutable next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapTupleIterator + extends SetMultimapTupleIterator { + final TransientTrieSetMultimap collection; + + public TransientSetMultimapTupleIterator(final TransientTrieSetMultimap collection, + final BiFunction tupleOf) { + super(collection.rootNode, tupleOf); + this.collection = collection; + } + + @Override + public T next() { + return super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.remove(currentKey, currentValue); + } + } + + // @Override + // public Set keySet() { + // Set keySet = null; + // + // if (keySet == null) { + // keySet = new AbstractSet() { + // @Override + // public Iterator iterator() { + // return TransientTrieSetMultimap.this.keyIterator(); + // } + // + // @Override + // public int size() { + // return TransientTrieSetMultimap.this.sizeDistinct(); + // } + // + // @Override + // public boolean isEmpty() { + // return TransientTrieSetMultimap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // TransientTrieSetMultimap.this.clear(); + // } + // + // @Override + // public boolean contains(Object k) { + // return TransientTrieSetMultimap.this.containsKey(k); + // } + // }; + // } + // + // return keySet; + // } + // + // @Override + // public Collection values() { + // Collection values = null; + // + // if (values == null) { + // values = new AbstractCollection() { + // @Override + // public Iterator iterator() { + // return TransientTrieSetMultimap.this.valueIterator(); + // } + // + // @Override + // public int size() { + // return TransientTrieSetMultimap.this.size(); + // } + // + // @Override + // public boolean isEmpty() { + // return TransientTrieSetMultimap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // TransientTrieSetMultimap.this.clear(); + // } + // + // @Override + // public boolean contains(Object v) { + // return TransientTrieSetMultimap.this.containsValue(v); + // } + // }; + // } + // + // return values; + // } + // + // @Override + // public Set> entrySet() { + // Set> entrySet = null; + // + // if (entrySet == null) { + // entrySet = new AbstractSet>() { + // @Override + // public Iterator> iterator() { + // return new Iterator>() { + // private final Iterator> i = entryIterator(); + // + // @Override + // public boolean hasNext() { + // return i.hasNext(); + // } + // + // @Override + // public Map.Entry next() { + // return i.next(); + // } + // + // @Override + // public void remove() { + // i.remove(); + // } + // }; + // } + // + // @Override + // public int size() { + // return TransientTrieSetMultimap.this.size(); + // } + // + // @Override + // public boolean isEmpty() { + // return TransientTrieSetMultimap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // TransientTrieSetMultimap.this.clear(); + // } + // + // @Override + // public boolean contains(Object k) { + // return TransientTrieSetMultimap.this.containsKey(k); + // } + // }; + // } + // + // return entrySet; + // } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieSetMultimap) { + TransientTrieSetMultimap that = (TransientTrieSetMultimap) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.cachedHashCode != that.cachedHashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + try { + @SuppressWarnings("unchecked") + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) + return false; + + for (Map.Entry entry : that) { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + @SuppressWarnings("unchecked") + final Set.Immutable valColl = (Set.Immutable) entry.getValue(); + + if (!result.get().equals(valColl)) { + return false; + } + } + } + } catch (ClassCastException unused) { + return false; + } + + return true; + + } + + return false; + } + + @Override + public int hashCode() { + return cachedHashCode; + } + + @Override + public SetMultimap.Immutable asImmutable() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieSetMultimap(cmp, rootNode, cachedHashCode, cachedSize); + } + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_ChampBasedPrototype.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_ChampBasedPrototype.java new file mode 100644 index 0000000..7005b1a --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_ChampBasedPrototype.java @@ -0,0 +1,3055 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.multimap; + +import java.text.DecimalFormat; +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Set; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.BiFunction; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import io.usethesource.capsule.SetMultimap; +import io.usethesource.capsule.util.EqualityComparator; +import io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap; +import io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableSet; + +@SuppressWarnings("rawtypes") +public class TrieSetMultimap_ChampBasedPrototype implements SetMultimap.Immutable { + + @SuppressWarnings("unchecked") + private static final TrieSetMultimap_ChampBasedPrototype EMPTY_SETMULTIMAP = + new TrieSetMultimap_ChampBasedPrototype(CompactSetMultimapNode.EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractSetMultimapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieSetMultimap_ChampBasedPrototype(AbstractSetMultimapNode rootNode, int hashCode, + int cachedSize) { + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + @SuppressWarnings("unchecked") + public static final SetMultimap.Immutable of() { + return TrieSetMultimap_ChampBasedPrototype.EMPTY_SETMULTIMAP; + } + + public static final SetMultimap.Immutable of(EqualityComparator cmp) { + return of(); // ignore cmp + } + + @SuppressWarnings("unchecked") + public static final SetMultimap.Immutable of(K key, V... values) { + SetMultimap.Immutable result = TrieSetMultimap_ChampBasedPrototype.EMPTY_SETMULTIMAP; + + for (V value : values) { + result = result.__insert(key, value); + } + + return result; + } + + @SuppressWarnings("unchecked") + public static final SetMultimap.Transient transientOf() { + return TrieSetMultimap_ChampBasedPrototype.EMPTY_SETMULTIMAP.asTransient(); + } + + @SuppressWarnings("unchecked") + public static final SetMultimap.Transient transientOf(K key, V... values) { + final SetMultimap.Transient result = + TrieSetMultimap_ChampBasedPrototype.EMPTY_SETMULTIMAP.asTransient(); + + for (V value : values) { + result.__insert(key, value); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext();) { + final io.usethesource.capsule.Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean containsKey(final Object o) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o0; + @SuppressWarnings("unchecked") + final V val = (V) o1; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get().contains(val); + } else { + return false; + } + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsEntryEquivalent(final Object o0, final Object o1, + final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o0; + @SuppressWarnings("unchecked") + final V val = (V) o1; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get().containsEquivalent(val, cmp); + } else { + return false; + } + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public io.usethesource.capsule.Set.Immutable getEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public SetMultimap.Immutable __put(final K key, final V val) { + throw new UnsupportedOperationException(); + } + + @Override + public SetMultimap.Immutable __insert(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + final int valHash = val.hashCode(); + return new TrieSetMultimap_ChampBasedPrototype(newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + public SetMultimap.Immutable __insertEquivalent(final K key, final V val, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + final int valHash = val.hashCode(); + return new TrieSetMultimap_ChampBasedPrototype(newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable union( + final SetMultimap setMultimap) { + final SetMultimap.Transient tmpTransient = this.asTransient(); + tmpTransient.union(setMultimap); + return tmpTransient.freeze(); + } + + @Override + public SetMultimap.Immutable __remove(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(null, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap_ChampBasedPrototype(newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + public SetMultimap.Immutable __removeEntryEquivalent(final K key, final V val, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap_ChampBasedPrototype(newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new SetMultimapKeyIterator<>(rootNode); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(Set::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + return new SetMultimapTupleIterator<>(rootNode, AbstractSpecialisedImmutableMap::entryOf); + } + + @Override + public Iterator> nativeEntryIterator() { + throw new UnsupportedOperationException(); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new SetMultimapTupleIterator<>(rootNode, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieSetMultimap_ChampBasedPrototype.this.keyIterator(); + } + + @Override + public int size() { + return TrieSetMultimap_ChampBasedPrototype.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_ChampBasedPrototype.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieSetMultimap_ChampBasedPrototype.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieSetMultimap_ChampBasedPrototype.this.valueIterator(); + } + + @Override + public int size() { + return TrieSetMultimap_ChampBasedPrototype.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_ChampBasedPrototype.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TrieSetMultimap_ChampBasedPrototype.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public io.usethesource.capsule.Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieSetMultimap_ChampBasedPrototype.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_ChampBasedPrototype.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieSetMultimap_ChampBasedPrototype.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieSetMultimap_ChampBasedPrototype) { + TrieSetMultimap_ChampBasedPrototype that = + (TrieSetMultimap_ChampBasedPrototype) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) + return false; + + for (@SuppressWarnings("unchecked") + Iterator it = that.entrySet().iterator(); it.hasNext();) { + io.usethesource.capsule.Map.Entry entry = it.next(); + + try { + @SuppressWarnings("unchecked") + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + @SuppressWarnings("unchecked") + final io.usethesource.capsule.Set.Immutable valColl = (io.usethesource.capsule.Set.Immutable) entry.getValue(); + + if (!result.get().equals(valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public SetMultimap.Transient asTransient() { + return new TransientTrieSetMultimap_BleedingEdge(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractSetMultimapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieSetMultimap_BleedingEdgeNodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. Payload X Node + */ + protected int[][] arityCombinationsHistogram() { + final Iterator> it = nodeIterator(); + final int[][] sumArityCombinations = new int[33][33]; + + while (it.hasNext()) { + final AbstractSetMultimapNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[33]; + + final int maxArity = 32; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[33]; + for (int cumsum = 0, i = 0; i < 33; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 33; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + abstract static class Optional { + private static final Optional EMPTY = new Optional() { + @Override + boolean isPresent() { + return false; + } + + @Override + Object get() { + return null; + } + }; + + @SuppressWarnings("unchecked") + static Optional empty() { + return EMPTY; + } + + static Optional of(T value) { + return new Value(value); + } + + abstract boolean isPresent(); + + abstract T get(); + + private static final class Value extends Optional { + private final T value; + + private Value(T value) { + this.value = value; + } + + @Override + boolean isPresent() { + return true; + } + + @Override + T get() { + return value; + } + } + } + + static final class SetMultimapResult { + private V replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(V replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static SetMultimapResult unchanged() { + return new SetMultimapResult<>(); + } + + private SetMultimapResult() {} + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public V getReplacedValue() { + return replacedValue; + } + } + + protected static interface INode { + } + + protected static abstract class AbstractSetMultimapNode implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final K key, final int keyHash, final int shift); + + abstract boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional> findByKey(final K key, final int keyHash, final int shift); + + abstract Optional> findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract CompactSetMultimapNode updated(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details); + + abstract CompactSetMultimapNode updated(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, final Comparator cmp); + + abstract CompactSetMultimapNode removed(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details); + + abstract CompactSetMultimapNode removed(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, final Comparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractSetMultimapNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractSetMultimapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) + throw new NoSuchElementException(); + return AbstractSetMultimapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract K getKey(final int index); + + abstract io.usethesource.capsule.Set.Immutable getValue(final int index); + + @Deprecated + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + int size() { + final Iterator it = new SetMultimapKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactSetMultimapNode + extends AbstractSetMultimapNode { + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + abstract int nodeMap(); + + abstract int dataMap(); + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactSetMultimapNode getNode(final int index); + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactSetMultimapNode copyAndSetValue(final AtomicReference mutator, + final int bitpos, final io.usethesource.capsule.Set.Immutable valColl); + + abstract CompactSetMultimapNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final K key, final io.usethesource.capsule.Set.Immutable valColl); + + abstract CompactSetMultimapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos); + + abstract CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final int bitpos, final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndMigrateFromInlineToNode( + final AtomicReference mutator, final int bitpos, + final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndMigrateFromNodeToInline( + final AtomicReference mutator, final int bitpos, + final CompactSetMultimapNode node); + + static final CompactSetMultimapNode mergeTwoKeyValPairs(final K key0, + final io.usethesource.capsule.Set.Immutable valColl0, final int keyHash0, final K key1, + final io.usethesource.capsule.Set.Immutable valColl1, final int keyHash1, final int shift) { + assert !(key0.equals(key1)); + + if (shift >= HASH_CODE_LENGTH) { + // throw new + // IllegalStateException("Hash collision not yet fixed."); + return new HashCollisionSetMultimapNode_BleedingEdge<>(keyHash0, + (K[]) new Object[] {key0, key1}, + (io.usethesource.capsule.Set.Immutable[]) new io.usethesource.capsule.Set.Immutable[] {valColl0, valColl1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int dataMap = bitpos(mask0) | bitpos(mask1); + + if (mask0 < mask1) { + return nodeOf(null, (0), dataMap, new Object[] {key0, valColl0, key1, valColl1}); + } else { + return nodeOf(null, (0), dataMap, new Object[] {key1, valColl1, key0, valColl0}); + } + } else { + final CompactSetMultimapNode node = mergeTwoKeyValPairs(key0, valColl0, keyHash0, + key1, valColl1, keyHash1, shift + BIT_PARTITION_SIZE); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf(null, nodeMap, (0), new Object[] {node}); + } + } + + static final CompactSetMultimapNode EMPTY_NODE; + + static { + + EMPTY_NODE = new BitmapIndexedSetMultimapNode<>(null, (0), (0), new Object[] {}); + + }; + + static final CompactSetMultimapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object[] nodes) { + return new BitmapIndexedSetMultimapNode<>(mutator, nodeMap, dataMap, nodes); + } + + @SuppressWarnings("unchecked") + static final CompactSetMultimapNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactSetMultimapNode nodeOf(AtomicReference mutator, + final int nodeMap, final int dataMap, final K key, final io.usethesource.capsule.Set.Immutable valColl) { + assert nodeMap == 0; + return nodeOf(mutator, (0), dataMap, new Object[] {key, valColl}); + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + CompactSetMultimapNode nodeAt(final int bitpos) { + return getNode(nodeIndex(bitpos)); + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index).equals(key); + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return false; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return cmp.compare(getKey(index), key) == 0; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return false; + } + + @Override + Optional> findByKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index).equals(key)) { + final io.usethesource.capsule.Set.Immutable result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractSetMultimapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return Optional.empty(); + } + + @Override + Optional> findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (cmp.compare(getKey(index), key) == 0) { + final io.usethesource.capsule.Set.Immutable result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractSetMultimapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return Optional.empty(); + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (currentKey.equals(key)) { + final io.usethesource.capsule.Set.Immutable valColl = getValue(dataIndex); + + final int valHash = val.hashCode(); + // if(valColl.contains(val, transformHashCode(valHash), 0)) + // { + if (valColl.contains(val)) { + return this; + } else { + // add new mapping + // final Immutable valCollNew = + // valColl.updated(null, val, + // transformHashCode(valHash), 0, details); + final io.usethesource.capsule.Set.Immutable valCollNew = valColl.__insert(val); + + details.modified(); + return copyAndSetValue(mutator, bitpos, valCollNew); + } + } else { + final int valHash = val.hashCode(); + // final Immutable valColl = + // CompactSetNode.EMPTY_NODE.updated(null, val, + // transformHashCode(valHash), 0, details); + final io.usethesource.capsule.Set.Immutable valColl = AbstractSpecialisedImmutableSet.setOf(val); + + final io.usethesource.capsule.Set.Immutable currentValNode = getValue(dataIndex); + final CompactSetMultimapNode subNodeNew = mergeTwoKeyValPairs(currentKey, + currentValNode, transformHashCode(currentKey.hashCode()), key, valColl, keyHash, + shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetMultimapNode subNode = nodeAt(bitpos); + final CompactSetMultimapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + final int valHash = val.hashCode(); + // final Immutable valColl = + // CompactSetNode.EMPTY_NODE.updated(null, val, + // transformHashCode(valHash), 0, details); + final io.usethesource.capsule.Set.Immutable valColl = AbstractSpecialisedImmutableSet.setOf(val); + + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, valColl); + } + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (cmp.compare(currentKey, key) == 0) { + final io.usethesource.capsule.Set.Immutable valColl = getValue(dataIndex); + + final int valHash = val.hashCode(); + // if(valColl.contains(val, transformHashCode(valHash), 0)) + // { + if (valColl.contains(val)) { + return this; + } else { + // add new mapping + // final Immutable valCollNew = + // valColl.updated(null, val, + // transformHashCode(valHash), 0, details); + final io.usethesource.capsule.Set.Immutable valCollNew = valColl.__insert(val); + + details.modified(); + return copyAndSetValue(mutator, bitpos, valCollNew); + } + } else { + final int valHash = val.hashCode(); + // final Immutable valColl = + // CompactSetNode.EMPTY_NODE.updated(null, val, + // transformHashCode(valHash), 0, details); + final io.usethesource.capsule.Set.Immutable valColl = AbstractSpecialisedImmutableSet.setOf(val); + + final io.usethesource.capsule.Set.Immutable currentValNode = getValue(dataIndex); + final CompactSetMultimapNode subNodeNew = mergeTwoKeyValPairs(currentKey, + currentValNode, transformHashCode(currentKey.hashCode()), key, valColl, keyHash, + shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetMultimapNode subNode = nodeAt(bitpos); + final CompactSetMultimapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + final int valHash = val.hashCode(); + // final Immutable valColl = + // CompactSetNode.EMPTY_NODE.updated(null, val, + // transformHashCode(valHash), 0, details); + final io.usethesource.capsule.Set.Immutable valColl = AbstractSpecialisedImmutableSet.setOf(val); + + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, valColl); + } + } + + @Override + CompactSetMultimapNode removed(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex).equals(key)) { + final io.usethesource.capsule.Set.Immutable valColl = getValue(dataIndex); + + final int valHash = val.hashCode(); + // if(valColl.contains(val, transformHashCode(valHash), 0)) + // { + if (valColl.contains(val)) { + details.updated(val); + + // remove mapping + // final Immutable valCollNew = + // valColl.removed(null, val, + // transformHashCode(valHash), 0, details); + final io.usethesource.capsule.Set.Immutable valCollNew = valColl.__remove(val); + + if (valCollNew.size() == 0) { // earlier: arity() == 0 + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new + * root returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactSetMultimapNode.nodeOf(mutator, 0, newDataMap, getKey(1), + getValue(1)); + } else { + return CompactSetMultimapNode.nodeOf(mutator, 0, newDataMap, getKey(0), + getValue(0)); + } + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return copyAndSetValue(mutator, bitpos, valCollNew); + } + } else { + return this; + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetMultimapNode subNode = nodeAt(bitpos); + final CompactSetMultimapNode subNodeNew = + subNode.removed(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (this.payloadArity() == 0 && this.nodeArity() == 1) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + @Override + CompactSetMultimapNode removed(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (cmp.compare(getKey(dataIndex), key) == 0) { + final io.usethesource.capsule.Set.Immutable valColl = getValue(dataIndex); + + final int valHash = val.hashCode(); + // if(valColl.contains(val, transformHashCode(valHash), 0)) + // { + if (valColl.contains(val)) { + details.updated(val); + + // remove mapping + // final Immutable valCollNew = + // valColl.removed(null, val, + // transformHashCode(valHash), 0, details); + final io.usethesource.capsule.Set.Immutable valCollNew = valColl.__remove(val); + + if (valCollNew.size() == 0) { // earlier: arity() == 0 + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new + * root returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactSetMultimapNode.nodeOf(mutator, 0, newDataMap, getKey(1), + getValue(1)); + } else { + return CompactSetMultimapNode.nodeOf(mutator, 0, newDataMap, getKey(0), + getValue(0)); + } + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return copyAndSetValue(mutator, bitpos, valCollNew); + } + } else { + return this; + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetMultimapNode subNode = nodeAt(bitpos); + final CompactSetMultimapNode subNodeNew = + subNode.removed(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (this.payloadArity() == 0 && this.nodeArity() == 1) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getKey(i)), + Objects.hashCode(getValue(i)))); + + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedSetMultimapNode + extends CompactSetMultimapNode { + + private final int nodeMap; + private final int dataMap; + + CompactMixedSetMultimapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + private static final class BitmapIndexedSetMultimapNode + extends CompactMixedSetMultimapNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedSetMultimapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + super(mutator, nodeMap, dataMap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + + assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < TUPLE_LENGTH * payloadArity(); i++) { + assert ((nodes[i] instanceof CompactSetMultimapNode) == false); + } + for (int i = TUPLE_LENGTH * payloadArity(); i < nodes.length; i++) { + assert ((nodes[i] instanceof CompactSetMultimapNode) == true); + } + + for (int i = 1; i < TUPLE_LENGTH * payloadArity(); i += 2) { + assert ((nodes[i] instanceof io.usethesource.capsule.Set.Immutable) == true); + } + } + + assert nodeInvariant(); + } + + @SuppressWarnings("unchecked") + @Override + K getKey(final int index) { + return (K) nodes[TUPLE_LENGTH * index]; + } + + @SuppressWarnings("unchecked") + @Override + io.usethesource.capsule.Set.Immutable getValue(final int index) { + return (io.usethesource.capsule.Set.Immutable) nodes[TUPLE_LENGTH * index + 1]; + } + + @SuppressWarnings("unchecked") + @Override + CompactSetMultimapNode getNode(final int index) { + return (CompactSetMultimapNode) nodes[nodes.length - 1 - index]; + } + + @Override + boolean hasPayload() { + return dataMap() != 0; + } + + @Override + int payloadArity() { + return java.lang.Integer.bitCount(dataMap()); + } + + @Override + boolean hasNodes() { + return nodeMap() != 0; + } + + @Override + int nodeArity() { + return java.lang.Integer.bitCount(nodeMap()); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + (nodeMap()); + result = prime * result + (dataMap()); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedSetMultimapNode that = (BitmapIndexedSetMultimapNode) other; + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + if (!Arrays.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + if (this.nodeArity() == 0) { + switch (this.payloadArity()) { + case 0: + return SIZE_EMPTY; + case 1: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } else { + return SIZE_MORE_THAN_ONE; + } + } + + @Override + CompactSetMultimapNode copyAndSetValue(final AtomicReference mutator, + final int bitpos, final io.usethesource.capsule.Set.Immutable valColl) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos) + 1; + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = valColl; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = valColl; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final int bitpos, final CompactSetMultimapNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(bitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactSetMultimapNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final K key, final io.usethesource.capsule.Set.Immutable valColl) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = valColl; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + return nodeOf(mutator, nodeMap(), dataMap() | bitpos, dst); + } + + @Override + CompactSetMultimapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + return nodeOf(mutator, nodeMap(), dataMap() ^ bitpos, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromInlineToNode( + final AtomicReference mutator, final int bitpos, + final CompactSetMultimapNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2 + 1]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 2, dst, idxNew + 1, src.length - idxNew - 2); + + return nodeOf(mutator, nodeMap() | bitpos, dataMap() ^ bitpos, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToInline( + final AtomicReference mutator, final int bitpos, + final CompactSetMultimapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 2]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = node.getKey(0); + dst[idxNew + 1] = node.getValue(0); + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 2, src.length - idxOld - 1); + + return nodeOf(mutator, nodeMap() ^ bitpos, dataMap() | bitpos, dst); + } + + } + + private static final class HashCollisionSetMultimapNode_BleedingEdge + extends CompactSetMultimapNode { + private final K[] keys; + private final io.usethesource.capsule.Set.Immutable[] vals; + private final int hash; + + HashCollisionSetMultimapNode_BleedingEdge(final int hash, final K[] keys, + final io.usethesource.capsule.Set.Immutable[] vals) { + this.keys = keys; + this.vals = vals; + this.hash = hash; + + assert payloadArity() >= 2; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (K k : keys) { + if (k.equals(key)) { + return true; + } + } + } + return false; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (K k : keys) { + if (cmp.compare(k, key) == 0) { + return true; + } + } + } + return false; + } + + @Override + Optional> findByKey(final K key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (key.equals(_key)) { + final io.usethesource.capsule.Set.Immutable valColl = vals[i]; + return Optional.of(valColl); + } + } + return Optional.empty(); + } + + @Override + Optional> findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (cmp.compare(key, _key) == 0) { + final io.usethesource.capsule.Set.Immutable valColl = vals[i]; + return Optional.of(valColl); + } + } + return Optional.empty(); + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final io.usethesource.capsule.Set.Immutable currentValColl = vals[idx]; + + if (currentValColl.contains(val)) { + return this; + } else { + // add new mapping + final io.usethesource.capsule.Set.Immutable valCollNew = currentValColl.__insert(val); + + final io.usethesource.capsule.Set.Immutable[] src = this.vals; + @SuppressWarnings("unchecked") + final io.usethesource.capsule.Set.Immutable[] dst = new io.usethesource.capsule.Set.Immutable[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = valCollNew; + + final CompactSetMultimapNode thisNew = + new HashCollisionSetMultimapNode_BleedingEdge<>(this.hash, this.keys, dst); + + details.modified(); + return thisNew; + } + } + } + + // add new tuple + final io.usethesource.capsule.Set.Immutable valCollNew = AbstractSpecialisedImmutableSet.setOf(val); + + @SuppressWarnings("unchecked") + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + @SuppressWarnings("unchecked") + final io.usethesource.capsule.Set.Immutable[] valsNew = new io.usethesource.capsule.Set.Immutable[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = valCollNew; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionSetMultimapNode_BleedingEdge<>(keyHash, keysNew, valsNew); + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final io.usethesource.capsule.Set.Immutable currentValColl = vals[idx]; + + if (currentValColl.containsEquivalent(val, cmp)) { + return this; + } else { + // add new mapping + final io.usethesource.capsule.Set.Immutable valCollNew = currentValColl.__insert(val); + + final io.usethesource.capsule.Set.Immutable[] src = this.vals; + @SuppressWarnings("unchecked") + final io.usethesource.capsule.Set.Immutable[] dst = new io.usethesource.capsule.Set.Immutable[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = valCollNew; + + final CompactSetMultimapNode thisNew = + new HashCollisionSetMultimapNode_BleedingEdge<>(this.hash, this.keys, dst); + + details.modified(); + return thisNew; + } + } + } + + // add new tuple + final io.usethesource.capsule.Set.Immutable valCollNew = AbstractSpecialisedImmutableSet.setOf(val); + + @SuppressWarnings("unchecked") + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + @SuppressWarnings("unchecked") + final io.usethesource.capsule.Set.Immutable[] valsNew = new io.usethesource.capsule.Set.Immutable[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = valCollNew; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionSetMultimapNode_BleedingEdge<>(keyHash, keysNew, valsNew); + } + + @Override + CompactSetMultimapNode removed(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final io.usethesource.capsule.Set.Immutable currentValColl = getValue(idx); + + if (currentValColl.contains(val)) { + details.updated(val); + + // remove tuple + final io.usethesource.capsule.Set.Immutable valCollNew = currentValColl.__remove(val); + + if (valCollNew.size() != 0) { + // update mapping + @SuppressWarnings("unchecked") + final io.usethesource.capsule.Set.Immutable[] valsNew = new io.usethesource.capsule.Set.Immutable[this.vals.length]; + + // copy 'this.vals' and set 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, this.vals.length); + valsNew[idx + 0] = valCollNew; + + return new HashCollisionSetMultimapNode_BleedingEdge<>(keyHash, keys, valsNew); + } else { + // drop mapping + if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new + * root returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final io.usethesource.capsule.Set.Immutable theOtherVal = (idx == 0) ? vals[1] : vals[0]; + + final int nodeMap = 0; + final int dataMap = bitpos(mask(hash, 0)); + + return CompactSetMultimapNode.nodeOf(mutator, nodeMap, dataMap, theOtherKey, + theOtherVal); + } else { + @SuppressWarnings("unchecked") + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at + // position 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + @SuppressWarnings("unchecked") + final io.usethesource.capsule.Set.Immutable[] valsNew = new io.usethesource.capsule.Set.Immutable[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at + // position 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionSetMultimapNode_BleedingEdge<>(keyHash, keysNew, valsNew); + } + } + } else { + return this; + } + } + } + return this; + } + + @Override + CompactSetMultimapNode removed(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final io.usethesource.capsule.Set.Immutable currentValColl = getValue(idx); + + if (currentValColl.contains(val)) { + details.updated(val); + + // remove tuple + final io.usethesource.capsule.Set.Immutable valCollNew = currentValColl.__removeEquivalent(val, cmp); + + if (valCollNew.size() != 0) { + // update mapping + @SuppressWarnings("unchecked") + final io.usethesource.capsule.Set.Immutable[] valsNew = new io.usethesource.capsule.Set.Immutable[this.vals.length]; + + // copy 'this.vals' and set 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, this.vals.length); + valsNew[idx + 0] = valCollNew; + + return new HashCollisionSetMultimapNode_BleedingEdge<>(keyHash, keys, valsNew); + } else { + // drop mapping + if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new + * root returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final io.usethesource.capsule.Set.Immutable theOtherVal = (idx == 0) ? vals[1] : vals[0]; + + final int nodeMap = 0; + final int dataMap = bitpos(mask(hash, 0)); + + return CompactSetMultimapNode.nodeOf(mutator, nodeMap, dataMap, theOtherKey, + theOtherVal); + } else { + @SuppressWarnings("unchecked") + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at + // position 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + @SuppressWarnings("unchecked") + final io.usethesource.capsule.Set.Immutable[] valsNew = new io.usethesource.capsule.Set.Immutable[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at + // position 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionSetMultimapNode_BleedingEdge<>(keyHash, keysNew, valsNew); + } + } + } else { + return this; + } + } + } + return this; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return keys.length; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + int arity() { + return payloadArity(); + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + K getKey(final int index) { + return keys[index]; + } + + @Override + io.usethesource.capsule.Set.Immutable getValue(final int index) { + return vals[index]; + } + + @Override + public CompactSetMultimapNode getNode(int index) { + throw new IllegalStateException("Is leaf node."); + } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + hash; + result = prime * result + Arrays.hashCode(keys); + result = prime * result + Arrays.hashCode(vals); + return result; + } + + @Override + public boolean equals(Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + HashCollisionSetMultimapNode_BleedingEdge that = + (HashCollisionSetMultimapNode_BleedingEdge) other; + + if (hash != that.hash) { + return false; + } + + if (arity() != that.arity()) { + return false; + } + + /* + * Linear scan for each key, because of arbitrary element order. + */ + outerLoop: for (int i = 0; i < that.payloadArity(); i++) { + final Object otherKey = that.getKey(i); + final Object otherVal = that.getValue(i); + + for (int j = 0; j < keys.length; j++) { + final K key = keys[j]; + final io.usethesource.capsule.Set.Immutable valColl = vals[j]; + + if (key.equals(otherKey) && valColl.equals(otherVal)) { + continue outerLoop; + } + } + return false; + } + + return true; + } + + @Override + CompactSetMultimapNode copyAndSetValue(final AtomicReference mutator, + final int bitpos, final io.usethesource.capsule.Set.Immutable valColl) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetMultimapNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final K key, final io.usethesource.capsule.Set.Immutable valColl) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetMultimapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final int bitpos, final CompactSetMultimapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromInlineToNode( + final AtomicReference mutator, final int bitpos, + final CompactSetMultimapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToInline( + final AtomicReference mutator, final int bitpos, + final CompactSetMultimapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + int nodeMap() { + throw new UnsupportedOperationException(); + } + + @Override + int dataMap() { + throw new UnsupportedOperationException(); + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractSetMultimapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + @SuppressWarnings("unchecked") + AbstractSetMultimapNode[] nodes = new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapIterator(AbstractSetMultimapNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractSetMultimapNode nextNode = + nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetMultimapKeyIterator extends AbstractSetMultimapIterator + implements Iterator { + + SetMultimapKeyIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + protected static class SetMultimapValueIterator extends AbstractSetMultimapIterator + implements Iterator> { + + SetMultimapValueIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public io.usethesource.capsule.Set.Immutable next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getValue(currentValueCursor++); + } + } + + } + + protected static class SetMultimapTupleIterator extends AbstractSetMultimapIterator + implements Iterator { + + final BiFunction tupleOf; + + K currentKey = null; + V currentValue = null; + Iterator currentSetIterator = Collections.emptyIterator(); + + SetMultimapTupleIterator(AbstractSetMultimapNode rootNode, + final BiFunction tupleOf) { + super(rootNode); + this.tupleOf = tupleOf; + } + + @Override + public boolean hasNext() { + if (currentSetIterator.hasNext()) { + return true; + } else { + if (super.hasNext()) { + currentKey = currentValueNode.getKey(currentValueCursor); + currentSetIterator = currentValueNode.getValue(currentValueCursor).iterator(); + currentValueCursor++; + + return true; + } else { + return false; + } + } + } + + @Override + public T next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + currentValue = currentSetIterator.next(); + return tupleOf.apply(currentKey, currentValue); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieSetMultimap_BleedingEdgeNodeIterator + implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieSetMultimap_BleedingEdgeNodeIterator(AbstractSetMultimapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractSetMultimapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieSetMultimap_BleedingEdge + implements SetMultimap.Transient { + final private AtomicReference mutator; + private AbstractSetMultimapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieSetMultimap_BleedingEdge( + TrieSetMultimap_ChampBasedPrototype trieSetMultimap_BleedingEdge) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieSetMultimap_BleedingEdge.rootNode; + this.hashCode = trieSetMultimap_BleedingEdge.hashCode; + this.cachedSize = trieSetMultimap_BleedingEdge.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext();) { + final io.usethesource.capsule.Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean containsKey(final Object o) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o0; + @SuppressWarnings("unchecked") + final V val = (V) o1; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get().contains(val); + } else { + return false; + } + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsEntryEquivalent(final Object o0, final Object o1, + final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o0; + @SuppressWarnings("unchecked") + final V val = (V) o1; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get().containsEquivalent(val, cmp); + } else { + return false; + } + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public io.usethesource.capsule.Set.Immutable getEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public boolean __insert(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + public boolean __insertEquivalent(final K key, final V val, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean union(final SetMultimap setMultimap) { + boolean modified = false; + + for (io.usethesource.capsule.Map.Entry entry : setMultimap.entrySet()) { + modified |= this.__insert(entry.getKey(), entry.getValue()); + } + + return modified; + } + + public boolean __insertAllEquivalent(final SetMultimap setMultimap, + final Comparator cmp) { + boolean modified = false; + + for (io.usethesource.capsule.Map.Entry entry : setMultimap.entrySet()) { + modified |= this.__insertEquivalent(entry.getKey(), entry.getValue(), cmp); + } + + return modified; + } + + @Override + public boolean __remove(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(mutator, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return false; + } + + public boolean __removeTupleEquivalent(final K key, final V val, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return false; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new TransientSetMultimapKeyIterator<>(this); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(Set::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + return new TransientSetMultimapTupleIterator<>(this, + AbstractSpecialisedImmutableMap::entryOf); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new TransientSetMultimapTupleIterator<>(this, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + public static class TransientSetMultimapKeyIterator extends SetMultimapKeyIterator { + final TransientTrieSetMultimap_BleedingEdge collection; + K lastKey; + + public TransientSetMultimapKeyIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapValueIterator + extends SetMultimapValueIterator { + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapValueIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public io.usethesource.capsule.Set.Immutable next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapTupleIterator + extends SetMultimapTupleIterator { + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapTupleIterator( + final TransientTrieSetMultimap_BleedingEdge collection, + final BiFunction tupleOf) { + super(collection.rootNode, tupleOf); + this.collection = collection; + } + + @Override + public T next() { + return super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(currentKey, currentValue); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieSetMultimap_BleedingEdge.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public io.usethesource.capsule.Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieSetMultimap_BleedingEdge) { + TransientTrieSetMultimap_BleedingEdge that = + (TransientTrieSetMultimap_BleedingEdge) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) + return false; + + for (@SuppressWarnings("unchecked") + Iterator it = that.entrySet().iterator(); it.hasNext();) { + io.usethesource.capsule.Map.Entry entry = it.next(); + + try { + @SuppressWarnings("unchecked") + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + @SuppressWarnings("unchecked") + final io.usethesource.capsule.Set.Immutable valColl = (io.usethesource.capsule.Set.Immutable) entry.getValue(); + + if (!result.get().equals(valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public SetMultimap.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieSetMultimap_ChampBasedPrototype(rootNode, hashCode, cachedSize); + } + } + + @Override + public SetMultimap.Immutable __remove(K key) { + throw new UnsupportedOperationException(); + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT.java new file mode 100644 index 0000000..0534e8b --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT.java @@ -0,0 +1,4058 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.multimap; + +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Deque; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import io.usethesource.capsule.SetMultimap; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT.EitherSingletonOrCollection.Type; +import io.usethesource.capsule.util.EqualityComparator; +import io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap; + +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_DATA_COLLECTION; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_DATA_SINGLETON; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_EMPTY; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_NODE; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setBitPattern; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setOf; +import static io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT.EitherSingletonOrCollection.Type.COLLECTION; +import static io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT.EitherSingletonOrCollection.Type.SINGLETON; +import static io.usethesource.capsule.util.BitmapUtils.filter; +import static io.usethesource.capsule.util.BitmapUtils.index; +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +public class TrieSetMultimap_HHAMT implements SetMultimap.Immutable { + + private final EqualityComparator cmp; + + private static final TrieSetMultimap_HHAMT EMPTY_SETMULTIMAP = + new TrieSetMultimap_HHAMT(EqualityComparator.EQUALS, CompactSetMultimapNode.EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractSetMultimapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieSetMultimap_HHAMT(EqualityComparator cmp, AbstractSetMultimapNode rootNode, + int hashCode, int cachedSize) { + this.cmp = cmp; + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final SetMultimap.Immutable of() { + return TrieSetMultimap_HHAMT.EMPTY_SETMULTIMAP; + } + + public static final SetMultimap.Immutable of(EqualityComparator cmp) { + // TODO: unify with `of()` + return new TrieSetMultimap_HHAMT(cmp, CompactSetMultimapNode.EMPTY_NODE, 0, 0); + } + + public static final SetMultimap.Immutable of(K key, V... values) { + SetMultimap.Immutable result = TrieSetMultimap_HHAMT.EMPTY_SETMULTIMAP; + + for (V value : values) { + result = result.__insert(key, value); + } + + return result; + } + + public static final SetMultimap.Transient transientOf() { + return TrieSetMultimap_HHAMT.EMPTY_SETMULTIMAP.asTransient(); + } + + public static final SetMultimap.Transient transientOf(K key, V... values) { + final SetMultimap.Transient result = TrieSetMultimap_HHAMT.EMPTY_SETMULTIMAP + .asTransient(); + + for (V value : values) { + result.__insert(key, value); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.equals(iterator.next(), o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + return rootNode.containsTuple(key, val, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public SetMultimap.Immutable __put(K key, V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieSetMultimap_HHAMT(cmp, newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + final int valHashNew = val.hashCode(); + + return new TrieSetMultimap_HHAMT(cmp, newRootNode, + hashCode + ((keyHash ^ valHashNew)) - sumOfReplacedHashes, + cachedSize - details.getReplacedCollection().size() + 1); + } + } + + final int valHash = val.hashCode(); + return new TrieSetMultimap_HHAMT(cmp, newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable __insert(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + final int valHash = val.hashCode(); + return new TrieSetMultimap_HHAMT(cmp, newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable union( + final SetMultimap setMultimap) { + final SetMultimap.Transient tmpTransient = this.asTransient(); + tmpTransient.union(setMultimap); + return tmpTransient.freeze(); + } + + @Override + public SetMultimap.Immutable __remove(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap_HHAMT(cmp, newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable __remove(K key) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removedAll(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap_HHAMT(cmp, newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + return new TrieSetMultimap_HHAMT(cmp, newRootNode, hashCode - sumOfReplacedHashes, + cachedSize - details.getReplacedCollection().size()); + } + } + + return this; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + // return new SetMultimapKeyIterator<>(rootNode); + return new SetMultimapKeyIteratorSlotHistogram<>(rootNode); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(Set::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + // return new SetMultimapTupleIterator<>(rootNode, AbstractSpecialisedImmutableMap::entryOf); + return new SetMultimapFlattenedTupleIteratorSlotHistogram<>(rootNode); + } + + @Override + public Iterator> nativeEntryIterator() { + // return new SetMultimapNativeTupleIterator<>(rootNode); + return new SetMultimapNativeTupleIteratorSlotHistogram<>(rootNode); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new SetMultimapTupleIterator<>(rootNode, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieSetMultimap_HHAMT.this.keyIterator(); + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieSetMultimap_HHAMT.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieSetMultimap_HHAMT.this.valueIterator(); + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TrieSetMultimap_HHAMT.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieSetMultimap_HHAMT.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieSetMultimap_HHAMT) { + TrieSetMultimap_HHAMT that = (TrieSetMultimap_HHAMT) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + /* + * TODO: Fix __put(K key, Immutable valColl) for batch insertion and re-enabled + * fast-fail check. + */ + // if (this.hashCode != that.hashCode) { + // return false; + // } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + final io.usethesource.capsule.Set.Immutable valColl = (io.usethesource.capsule.Set.Immutable) entry + .getValue(); + + if (!cmp.equals(result.get(), valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public SetMultimap.Transient asTransient() { + return new TransientTrieSetMultimap_BleedingEdge(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractSetMultimapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieSetMultimap_BleedingEdgeNodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + static abstract class EitherSingletonOrCollection { + + public enum Type { + SINGLETON, COLLECTION + } + + public static final EitherSingletonOrCollection of(T value) { + return new SomeSingleton<>(value); + } + + public static final EitherSingletonOrCollection of( + io.usethesource.capsule.Set.Immutable value) { + return new SomeCollection<>(value); + } + + abstract boolean isType(Type type); + + abstract T getSingleton(); + + abstract io.usethesource.capsule.Set.Immutable getCollection(); + } + + static final class SomeSingleton extends EitherSingletonOrCollection { + + private final T value; + + private SomeSingleton(T value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.SINGLETON; + } + + @Override + T getSingleton() { + return value; + } + + @Override + io.usethesource.capsule.Set.Immutable getCollection() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.COLLECTION, Type.SINGLETON)); + } + } + + static final class SomeCollection extends EitherSingletonOrCollection { + + private final io.usethesource.capsule.Set.Immutable value; + + private SomeCollection(io.usethesource.capsule.Set.Immutable value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.COLLECTION; + } + + @Override + T getSingleton() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.SINGLETON, Type.COLLECTION)); + } + + @Override + io.usethesource.capsule.Set.Immutable getCollection() { + return value; + } + } + + static final class SetMultimapResult { + + private V replacedValue; + private io.usethesource.capsule.Set.Immutable replacedValueCollection; + private EitherSingletonOrCollection.Type replacedType; + + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(V replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + this.replacedType = SINGLETON; + } + + public void updated(io.usethesource.capsule.Set.Immutable replacedValueCollection) { + this.replacedValueCollection = replacedValueCollection; + this.isModified = true; + this.isReplaced = true; + this.replacedType = COLLECTION; + } + + // update: neither element, nor element count changed + public static SetMultimapResult unchanged() { + return new SetMultimapResult<>(); + } + + private SetMultimapResult() { + } + + public boolean isModified() { + return isModified; + } + + public EitherSingletonOrCollection.Type getType() { + return replacedType; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public V getReplacedValue() { + assert getType() == SINGLETON; + return replacedValue; + } + + public io.usethesource.capsule.Set.Immutable getReplacedCollection() { + assert getType() == COLLECTION; + return replacedValueCollection; + } + } + + protected static interface INode { + + } + + protected static abstract class AbstractSetMultimapNode implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract boolean containsTuple(final K key, final V val, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract Optional> findByKey(final K key, + final int keyHash, final int shift, + EqualityComparator cmp); + + abstract CompactSetMultimapNode inserted(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode updated(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode updated(final AtomicReference mutator, + final K key, final io.usethesource.capsule.Set.Immutable val, final int keyHash, + final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode removed(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode removedAll(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractSetMultimapNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractSetMultimapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractSetMultimapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract int emptyArity(); + + abstract boolean hasPayload(EitherSingletonOrCollection.Type type); + + // abstract int payloadArity(); + + abstract int payloadArity(EitherSingletonOrCollection.Type type); + + abstract K getSingletonKey(final int index); + + abstract V getSingletonValue(final int index); + + abstract K getCollectionKey(final int index); + + abstract io.usethesource.capsule.Set.Immutable getCollectionValue(final int index); + + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + abstract int arity(); + + abstract int arity(int pattern); + + abstract int[] slotRangeTuples(); + + int size() { + final Iterator it = new SetMultimapKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactSetMultimapNode + extends AbstractSetMultimapNode { + + CompactSetMultimapNode(final AtomicReference mutator, final long bitmap) { + this.bitmap = bitmap; + } + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + static final int doubledMask(int keyHash, int shift) { + final int mask = mask(keyHash, shift); + return mask << 1; + } + + static final long doubledBitpos(final int doubledMask) { + return 1L << doubledMask; + } + + static final int pattern(long bitmap, int doubledMask) { + return (int) ((bitmap >>> doubledMask) & 0b11); + } + + protected final long bitmap; + + final long bitmap() { + return bitmap; + } + + @Deprecated + @Override + int arity() { + // TODO: replace with 32 - arity(emptyMap) + // return arity(bitmap(), PATTERN_DATA_SINGLETON) + arity(bitmap(), PATTERN_DATA_COLLECTION) + + // arity(bitmap(), PATTERN_NODE); + + int[] arities = arities(bitmap()); + return Arrays.stream(arities).skip(1).sum(); + } + + @Override + final int arity(int pattern) { + return arity(bitmap, pattern); + } + + static final int arity(long bitmap, int pattern) { + // if (bitmap == 0) { + // if (pattern == PATTERN_EMPTY) { + // return 32; + // } else { + // return 0; + // } + // } else { + return Long.bitCount(filter(bitmap, pattern)); + // } + } + + // TODO: Implement arity histogram over bitmap (with single for loop) that calculates offsets + static final int[] arities(final long bitmap) { + int[] arities = new int[4]; + + long shiftedBitmap = bitmap; + for (int i = 0; i < 32; i++) { + arities[(int) shiftedBitmap & 0b11]++; + shiftedBitmap = shiftedBitmap >>> 2; + } + + return arities; + } + + @Override + public final int[] slotRangeTuples() { + return slotRangeTuplesOptimized(bitmap, 0); + } + + static final int[] slotRangeTuples(final long bitmap, final int startSlot) { + int[] offsetRangeTuples = new int[8]; + + offsetRangeTuples[0] = startSlot; + offsetRangeTuples[1] = offsetRangeTuples[0]; + + offsetRangeTuples[2] = offsetRangeTuples[1]; + offsetRangeTuples[3] = + offsetRangeTuples[2] + Long.bitCount(filter(bitmap, PATTERN_DATA_SINGLETON)) * 2; + + offsetRangeTuples[4] = offsetRangeTuples[3]; + offsetRangeTuples[5] = + offsetRangeTuples[4] + Long.bitCount(filter(bitmap, PATTERN_DATA_COLLECTION)) * 2; + + offsetRangeTuples[6] = offsetRangeTuples[5]; + offsetRangeTuples[7] = offsetRangeTuples[6] + Long.bitCount(filter(bitmap, PATTERN_NODE)); + + return offsetRangeTuples; + } + + static final int[] slotRangeTuplesOptimized(final long bitmap, final int startSlot) { + int[] offsetRangeTuples = new int[8]; + + long filteredData = filter(bitmap, PATTERN_DATA_SINGLETON); + long filteredColl = filter(bitmap, PATTERN_DATA_COLLECTION); + long filteredNode = filter(bitmap, PATTERN_NODE); + + offsetRangeTuples[0] = startSlot; + offsetRangeTuples[1] = offsetRangeTuples[0]; + + offsetRangeTuples[2] = offsetRangeTuples[1]; + offsetRangeTuples[3] = + offsetRangeTuples[2] + ((filteredData == 0L) ? 0 : (Long.bitCount(filteredData) * 2)); + + offsetRangeTuples[4] = offsetRangeTuples[3]; + offsetRangeTuples[5] = + offsetRangeTuples[4] + ((filteredColl == 0L) ? 0 : (Long.bitCount(filteredColl) * 2)); + + offsetRangeTuples[6] = offsetRangeTuples[5]; + offsetRangeTuples[7] = + offsetRangeTuples[6] + ((filteredNode == 0L) ? 0 : (Long.bitCount(filteredNode))); + + return offsetRangeTuples; + } + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactSetMultimapNode getNode(final int index); + + boolean nodeInvariant() { + return true; + // boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + // boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + // boolean inv3 = + // (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + // boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + // + // boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + // && ((this.payloadArity() + this.nodeArity()) == this.arity()); + // + // return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + final long bitmap); + + abstract CompactSetMultimapNode copyAndSetSingletonValue( + final AtomicReference mutator, final long doubledBitpos, final V val); + + abstract CompactSetMultimapNode copyAndSetCollectionValue( + final AtomicReference mutator, final long doubledBitpos, + final io.usethesource.capsule.Set.Immutable valColl); + + abstract CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final long doubledBitpos, final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndInsertSingleton( + final AtomicReference mutator, final long doubledBitpos, final K key, final V val); + + abstract CompactSetMultimapNode copyAndInsertCollection( + final AtomicReference mutator, final long doubledBitpos, final K key, + final io.usethesource.capsule.Set.Immutable valColl); + + abstract CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + final AtomicReference mutator, final long doubledBitpos, final K key, + final io.usethesource.capsule.Set.Immutable valColl); + + abstract CompactSetMultimapNode copyAndRemoveSingleton( + final AtomicReference mutator, final long doubledBitpos); + + abstract CompactSetMultimapNode copyAndRemoveSingleton( + final AtomicReference mutator, final long doubledBitpos, long updatedBitmap); + + /* + * Batch updated, necessary for removedAll. + */ + abstract CompactSetMultimapNode copyAndRemoveCollection( + final AtomicReference mutator, final long doubledBitpos); + + abstract CompactSetMultimapNode copyAndMigrateFromSingletonToNode( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndMigrateFromNodeToSingleton( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node); // node get's unwrapped inside method + + abstract CompactSetMultimapNode copyAndMigrateFromCollectionToNode( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndMigrateFromNodeToCollection( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node); // node get's unwrapped inside method + + abstract CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + final AtomicReference mutator, final long doubledBitpos, final K key, final V val); + + static final CompactSetMultimapNode mergeTwoSingletonPairs(final K key0, + final V val0, final int keyHash0, final K key1, final V val1, final int keyHash1, + final int shift, EqualityComparator cmp) { + assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode.of(keyHash0, key0, setOf(val0), key1, setOf(val1)); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_SINGLETON); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_SINGLETON); + + if (mask0 < mask1) { + return nodeOf(null, bitmap, new Object[]{key0, val0, key1, val1}); + } else { + return nodeOf(null, bitmap, new Object[]{key1, val1, key0, val0}); + } + } else { + final CompactSetMultimapNode node = mergeTwoSingletonPairs(key0, val0, keyHash0, key1, + val1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf(null, bitmap, new Object[]{node}); + } + } + + static final CompactSetMultimapNode mergeTwoCollectionPairs(final K key0, + final io.usethesource.capsule.Set.Immutable valColl0, final int keyHash0, final K key1, + final io.usethesource.capsule.Set.Immutable valColl1, final int keyHash1, + final int shift, + EqualityComparator cmp) { + assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode.of(keyHash0, key0, valColl0, key1, valColl1); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_COLLECTION); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_COLLECTION); + + if (mask0 < mask1) { + return nodeOf(null, bitmap, new Object[]{key0, valColl0, key1, valColl1}); + } else { + return nodeOf(null, bitmap, new Object[]{key1, valColl1, key0, valColl0}); + } + } else { + final CompactSetMultimapNode node = mergeTwoCollectionPairs(key0, valColl0, keyHash0, + key1, valColl1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf(null, bitmap, new Object[]{node}); + } + } + + static final CompactSetMultimapNode mergeCollectionAndSingletonPairs(final K key0, + final io.usethesource.capsule.Set.Immutable valColl0, final int keyHash0, final K key1, + final V val1, + final int keyHash1, final int shift, EqualityComparator cmp) { + assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode.of(keyHash0, key0, valColl0, key1, setOf(val1)); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_COLLECTION); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_SINGLETON); + + // singleton before collection + return nodeOf(null, bitmap, new Object[]{key1, val1, key0, valColl0}); + } else { + final CompactSetMultimapNode node = mergeCollectionAndSingletonPairs(key0, valColl0, + keyHash0, key1, val1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf(null, bitmap, new Object[]{node}); + } + } + + static final CompactSetMultimapNode EMPTY_NODE; + + static { + EMPTY_NODE = new BitmapIndexedSetMultimapNode<>(null, 0L, new Object[]{}); + } + + ; + + static final CompactSetMultimapNode nodeOf(final AtomicReference mutator, + final long bitmap, final Object[] nodes) { + return new BitmapIndexedSetMultimapNode<>(mutator, bitmap, nodes); + } + + static final CompactSetMultimapNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactSetMultimapNode nodeOf(AtomicReference mutator, + final long bitmap, final K key, final io.usethesource.capsule.Set.Immutable valColl) { + return nodeOf(mutator, bitmap, new Object[]{key, valColl}); + } + + @Deprecated + int dataIndex(final long doubledBitpos) { + return index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + } + + @Deprecated + int collIndex(final long doubledBitpos) { + return index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + } + + @Deprecated + int nodeIndex(final long doubledBitpos) { + return index(bitmap, PATTERN_NODE, doubledBitpos); + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + return cmp.equals(getSingletonKey(index), key); + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + return cmp.equals(getCollectionKey(index), key); + } + default: + return false; + } + } + + @Override + boolean containsTuple(final K key, final V val, final int keyHash, final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + + final AbstractSetMultimapNode subNode = getNode(index); + return subNode.containsTuple(key, val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(index); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(index); + return cmp.equals(currentVal, val); + } + + return false; + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(index); + if (cmp.equals(currentKey, key)) { + + final io.usethesource.capsule.Set.Immutable currentValColl = getCollectionValue( + index); + return currentValColl.contains(val); + } + + return false; + } + default: + return false; + } + } + + @Override + Optional> findByKey(final K key, final int keyHash, + final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + + final AbstractSetMultimapNode subNode = getNode(index); + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(index); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(index); + return Optional.of(setOf(currentVal)); + } + + return Optional.empty(); + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(index); + if (cmp.equals(currentKey, key)) { + + final io.usethesource.capsule.Set.Immutable currentValColl = getCollectionValue( + index); + return Optional.of(currentValColl); + } + + return Optional.empty(); + } + default: + return Optional.empty(); + } + } + + @Override + CompactSetMultimapNode inserted(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = subNode.inserted(mutator, key, val, + keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + if (cmp.equals(currentVal, val)) { + return this; + } else { + // migrate from singleton to collection + final io.usethesource.capsule.Set.Immutable valColl = setOf(currentVal, val); + + details.modified(); + return copyAndMigrateFromSingletonToCollection(mutator, doubledBitpos, currentKey, + valColl); + } + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final io.usethesource.capsule.Set.Immutable currentCollVal = getCollectionValue( + collIndex); + + if (currentCollVal.contains(val)) { + return this; + } else { + // add new mapping + final io.usethesource.capsule.Set.Immutable newCollVal = currentCollVal + .__insert(val); + + details.modified(); + return copyAndSetCollectionValue(mutator, doubledBitpos, newCollVal); + } + } else { + // prefix-collision (case: collection x singleton) + final io.usethesource.capsule.Set.Immutable currentValNode = getCollectionValue( + collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertSingleton(mutator, doubledBitpos, key, val); + } + } + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + // update singleton value + details.updated(currentVal); + return copyAndSetSingletonValue(mutator, doubledBitpos, val); + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final io.usethesource.capsule.Set.Immutable currentCollVal = getCollectionValue( + collIndex); + + // migrate from collection to singleton + details.updated(currentCollVal); + return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, currentCollKey, + val); + } else { + // prefix-collision (case: collection x singleton) + final io.usethesource.capsule.Set.Immutable currentValNode = getCollectionValue( + collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertSingleton(mutator, doubledBitpos, key, val); + } + } + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final io.usethesource.capsule.Set.Immutable valColl, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = subNode.updated(mutator, key, valColl, + keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + // migrate from singleton to collection + details.updated(currentVal); + return copyAndMigrateFromSingletonToCollection(mutator, doubledBitpos, currentKey, + valColl); + // + // + // // update singleton value + // details.updated(currentVal); + // return copyAndSetSingletonValue(mutator, doubledBitpos, valColl); + } else { + // prefix-collision (case: collection x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = + mergeCollectionAndSingletonPairs(key, valColl, keyHash, currentKey, currentVal, + transformHashCode(currentKey.hashCode()), shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, subNodeNew); + + // // prefix-collision (case: singleton x singleton) + // final V currentVal = getSingletonValue(dataIndex); + // + // final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + // currentVal, transformHashCode(currentKey.hashCode()), key, valColl, keyHash, + // shift + BIT_PARTITION_SIZE, cmp); + // + // details.modified(); + // return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final io.usethesource.capsule.Set.Immutable currentCollVal = getCollectionValue( + collIndex); + + // update collection value + details.updated(currentCollVal); + return copyAndSetCollectionValue(mutator, doubledBitpos, valColl); + + // // migrate from collection to singleton + // details.updated(currentCollVal); + // return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, + // currentCollKey, + // valColl); + } else { + // prefix-collision (case: collection x collection) + final io.usethesource.capsule.Set.Immutable currentValNode = getCollectionValue( + collIndex); + final CompactSetMultimapNode subNodeNew = mergeTwoCollectionPairs(currentCollKey, + currentValNode, transformHashCode(currentCollKey.hashCode()), key, valColl, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, subNodeNew); + + // // prefix-collision (case: collection x singleton) + // final Immutable currentValNode = getCollectionValue(collIndex); + // final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + // currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + // valColl, keyHash, shift + BIT_PARTITION_SIZE, cmp); + // + // details.modified(); + // return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertCollection(mutator, doubledBitpos, key, valColl); + } + } + } + + @Override + CompactSetMultimapNode removed(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.removed(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (slotArity() == 0) { + if (shift == 0) { + // singleton remaining + final long doubledBitposAtShift0 = doubledBitpos(bitpos(doubledMask(keyHash, 0))); + + final long updatedBitmapAtShift0 = + setBitPattern(doubledBitposAtShift0, subNodeNew.patternOfSingleton()); + + return subNodeNew.copyAndUpdateBitmaps(mutator, updatedBitmapAtShift0); + } else { + // escalate (singleton or empty) result + return subNodeNew; + } + } else { + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + } + + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(dataIndex); + if (cmp.equals(currentVal, val)) { + + // remove mapping + details.updated(val); + return copyAndRemoveSingleton(mutator, doubledBitpos); + } else { + return this; + } + } else { + return this; + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(collIndex); + if (cmp.equals(currentKey, key)) { + + final io.usethesource.capsule.Set.Immutable currentValColl = getCollectionValue( + collIndex); + if (currentValColl.contains(val)) { + + // remove mapping + details.updated(val); + + final io.usethesource.capsule.Set.Immutable newValColl = currentValColl + .__remove(val); + + if (newValColl.size() == 1) { + // TODO: investigate options for unboxing singleton collections + V remainingVal = newValColl.iterator().next(); + return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, key, + remainingVal); + } else { + return copyAndSetCollectionValue(mutator, doubledBitpos, newValColl); + } + } else { + return this; + } + } else { + return this; + } + } + default: + return this; + } + } + + final static boolean hasSingleNode(int[] arities) { + return arities[PATTERN_EMPTY] == 31 && arities[PATTERN_NODE] == 1; + } + + final static boolean hasTwoPayloads(int[] arities) { + return arities[PATTERN_EMPTY] == 30 && arities[PATTERN_NODE] == 0; + } + + enum State { + EMPTY, NODE, PAYLOAD, PAYLOAD_RARE + } + + static final State toState(final int pattern) { + // final State[] states = {State.EMPTY, State.NODE, State.PAYLOAD, State.PAYLOAD_RARE}; + // return states[pattern]; + + switch (pattern) { + case PATTERN_EMPTY: + return State.EMPTY; + case PATTERN_NODE: + return State.NODE; + case PATTERN_DATA_SINGLETON: + return State.PAYLOAD; + default: + return State.PAYLOAD_RARE; + } + } + + @Override + CompactSetMultimapNode removedAll(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.removedAll(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (slotArity() == 1) { + if (shift == 0) { + // singleton remaining + final long doubledBitposAtShift0 = doubledBitpos(bitpos(doubledMask(keyHash, 0))); + + final long updatedBitmapAtShift0 = + setBitPattern(doubledBitposAtShift0, subNodeNew.patternOfSingleton()); + + return subNodeNew.copyAndUpdateBitmaps(mutator, updatedBitmapAtShift0); + } else { + // escalate (singleton or empty) result + return subNodeNew; + } + } else { + // // inline value (move to front) + // final State subNodeState = subNodeNew.stateOfSingleton(); + // + //// switch (subNodeState) { + //// case EMPTY: + //// case NODE: + //// case PAYLOAD: + //// return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + //// case PAYLOAD_RARE: + //// return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + //// } + // + // if (subNodeState == State.PAYLOAD) { + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // } else { + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // } + + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + } + + // // inline value (move to front) + // final int subNodePattern = subNodeNew.patternOfSingleton(); + // + // if (subNodePattern == PATTERN_DATA_SINGLETON) { + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // } else { + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // } + + // switch (subNodePattern) { + // case PATTERN_DATA_SINGLETON: + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // case PATTERN_DATA_COLLECTION: + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // default: + // return null; + // } + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(dataIndex); + + details.updated(currentVal); + return copyAndRemoveSingleton(mutator, doubledBitpos); + } else { + return this; + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(collIndex); + if (cmp.equals(currentKey, key)) { + + final io.usethesource.capsule.Set.Immutable currentValColl = getCollectionValue( + collIndex); + + details.updated(currentValColl); + return copyAndRemoveCollection(mutator, doubledBitpos); + } else { + return this; + } + } + default: + return this; + } + } + + abstract int patternOfSingleton(); + + @Deprecated + abstract EitherSingletonOrCollection.Type typeOfSingleton(); + + @Deprecated + abstract State stateOfSingleton(); + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + long bitmap = this.bitmap(); + + int[] arities = arities(bitmap); + + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < arities[PATTERN_DATA_SINGLETON]; i++) { + final byte pos = -1; // TODO: recoverMask(dataMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getSingletonKey(i)), + Objects.hashCode(getSingletonValue(i)))); + + if (!((i + 1) == arities[PATTERN_DATA_SINGLETON])) { + bldr.append(", "); + } + } + + if (arities[PATTERN_DATA_SINGLETON] > 0 && arities[PATTERN_DATA_COLLECTION] > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arities[PATTERN_DATA_COLLECTION]; i++) { + final byte pos = -1; // TODO: recoverMask(collMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getCollectionKey(i)), + Objects.hashCode(getCollectionValue(i)))); + + if (!((i + 1) == arities[PATTERN_DATA_COLLECTION])) { + bldr.append(", "); + } + } + + if (arities[PATTERN_DATA_COLLECTION] > 0 && arities[PATTERN_NODE] > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arities[PATTERN_NODE]; i++) { + final byte pos = -1; // TODO: recoverMask(nodeMap, (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == arities[PATTERN_NODE])) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + private static final class BitmapIndexedSetMultimapNode + extends CompactSetMultimapNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedSetMultimapNode(final AtomicReference mutator, final long bitmap, + final Object[] nodes) { + super(mutator, bitmap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + int[] arities = arities(bitmap); + + assert (TUPLE_LENGTH * arities[PATTERN_DATA_SINGLETON] + + TUPLE_LENGTH * arities[PATTERN_DATA_COLLECTION] + + arities[PATTERN_NODE] == nodes.length); + + for (int i = 0; i < arities[PATTERN_DATA_SINGLETON]; i++) { + int offset = i * TUPLE_LENGTH; + + assert ((nodes[offset + 0] instanceof io.usethesource.capsule.Set.Immutable) == false); + assert ((nodes[offset + 1] instanceof io.usethesource.capsule.Set.Immutable) == false); + + assert ((nodes[offset + 0] instanceof CompactSetMultimapNode) == false); + assert ((nodes[offset + 1] instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arities[PATTERN_DATA_COLLECTION]; i++) { + int offset = (i + arities[PATTERN_DATA_SINGLETON]) * TUPLE_LENGTH; + + assert ((nodes[offset + 0] instanceof io.usethesource.capsule.Set.Immutable) == false); + assert ((nodes[offset + 1] instanceof io.usethesource.capsule.Set.Immutable) == true); + + assert ((nodes[offset + 0] instanceof CompactSetMultimapNode) == false); + assert ((nodes[offset + 1] instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arities[PATTERN_NODE]; i++) { + int offset = + (arities[PATTERN_DATA_SINGLETON] + arities[PATTERN_DATA_COLLECTION]) * TUPLE_LENGTH; + + assert ((nodes[offset + i] instanceof io.usethesource.capsule.Set.Immutable) == false); + + assert ((nodes[offset + i] instanceof CompactSetMultimapNode) == true); + } + } + + assert nodeInvariant(); + } + + @Override + K getSingletonKey(final int index) { + return (K) nodes[TUPLE_LENGTH * index]; + } + + @Override + V getSingletonValue(int index) { + return (V) nodes[TUPLE_LENGTH * index + 1]; + } + + @Override + K getCollectionKey(int index) { + // TODO: improve on offset calculation (caching it, etc) + int offset = TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + index); + return (K) nodes[offset]; + } + + @Override + io.usethesource.capsule.Set.Immutable getCollectionValue(final int index) { + // TODO: improve on offset calculation (caching it, etc) + int offset = TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + index) + 1; + return (io.usethesource.capsule.Set.Immutable) nodes[offset]; + } + + @Override + CompactSetMultimapNode getNode(final int index) { + return (CompactSetMultimapNode) nodes[nodes.length - 1 - index]; + } + + // @Override + // boolean hasPayload() { + // return rawMap2() != 0; + // } + // + // @Override + // int payloadArity() { + // return java.lang.Integer.bitCount(rawMap2()); + // } + + @Override + int emptyArity() { + return arity(bitmap(), PATTERN_EMPTY); + } + + @Override + boolean hasPayload(EitherSingletonOrCollection.Type type) { + return payloadArity(type) != 0; + } + + @Override + int payloadArity(EitherSingletonOrCollection.Type type) { + // int[] arities = arities(bitmap()); + // return arities[PATTERN_NODE]; + + if (type == Type.SINGLETON) { + // return arities[PATTERN_DATA_SINGLETON]; + return arity(bitmap(), PATTERN_DATA_SINGLETON); + } else { + // return arities[PATTERN_DATA_COLLECTION]; + return arity(bitmap(), PATTERN_DATA_COLLECTION); + } + } + + @Override + boolean hasNodes() { + return nodeArity() != 0; + } + + @Override + int nodeArity() { + return arity(bitmap, PATTERN_NODE); + } + + @Override + final Object getSlot(final int index) { + return nodes[index]; + } + + @Override + final boolean hasSlots() { + return nodes.length != 0; + } + + @Override + final int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = (int) (prime * result + (bitmap())); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedSetMultimapNode that = (BitmapIndexedSetMultimapNode) other; + if (bitmap() != that.bitmap()) { + return false; + } + if (!Arrays.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + + // switch (slotArity()) { + // case 0: + // return SIZE_EMPTY; + // case 1: + // return SIZE_MORE_THAN_ONE; // works for maps only: must be subnode; patternOfSingleton(); + // case 2: + // return arity(bitmap(), PATTERN_NODE) == 0 ? SIZE_ONE : SIZE_MORE_THAN_ONE; + // default: + // return SIZE_MORE_THAN_ONE; + // } + + // if (this.nodeArity() == 0) { + // switch (this.payloadArity()) { + // case 0: + // return SIZE_EMPTY; + // case 1: + // return SIZE_ONE; + // default: + // return SIZE_MORE_THAN_ONE; + // } + // } else { + // return SIZE_MORE_THAN_ONE; + // } + + // int[] arities = arities(bitmap()); + // + // int nodeArity = arities[PATTERN_NODE]; + // int emptyArity = arities[PATTERN_EMPTY]; + + final long bitmap = this.bitmap(); + + int nodeArity = arity(bitmap, PATTERN_NODE); + int emptyArity = arity(bitmap, PATTERN_EMPTY); + + // int aritySingleton = arity(bitmap, PATTERN_DATA_SINGLETON); + // int arityCollection = arity(bitmap, PATTERN_DATA_COLLECTION); + + if (nodeArity > 0) { + return SIZE_MORE_THAN_ONE; + } else { + switch (emptyArity) { + case 32: + return SIZE_EMPTY; + case 31: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } + + // if (this.nodeArity() == 0) { + // switch (arity(bitmap(), PATTERN_DATA_SINGLETON) + // + arity(bitmap(), PATTERN_DATA_COLLECTION)) { + // case 0: + // return SIZE_EMPTY; + // case 1: + // return SIZE_ONE; + // default: + // return SIZE_MORE_THAN_ONE; + // } + // } else { + // return SIZE_MORE_THAN_ONE; + // } + } + + @Override + CompactSetMultimapNode copyAndSetSingletonValue(final AtomicReference mutator, + final long doubledBitpos, final V val) { + + final int idx = TUPLE_LENGTH * dataIndex(doubledBitpos) + 1; + final CompactSetMultimapNode updatedNode = copyAndSetXxxValue(mutator, idx, val); + + return updatedNode; + } + + @Override + CompactSetMultimapNode copyAndSetCollectionValue(final AtomicReference mutator, + final long doubledBitpos, final io.usethesource.capsule.Set.Immutable valColl) { + + final int idx = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)) + 1; + final CompactSetMultimapNode updatedNode = copyAndSetXxxValue(mutator, idx, valColl); + + return updatedNode; + } + + private CompactSetMultimapNode copyAndSetXxxValue(final AtomicReference mutator, + final int idx, final Object newValue) { + final CompactSetMultimapNode updatedNode; + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = newValue; + updatedNode = this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = newValue; + + updatedNode = nodeOf(mutator, bitmap(), dst); + } + return updatedNode; + } + + @Override + CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final long doubledBitpos, final CompactSetMultimapNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(doubledBitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, bitmap(), dst); + } + } + + @Override + CompactSetMultimapNode copyAndInsertSingleton(final AtomicReference mutator, + final long doubledBitpos, final K key, final V val) { + final int idx = TUPLE_LENGTH * dataIndex(doubledBitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = val; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + long updatedBitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_SINGLETON); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndInsertCollection(final AtomicReference mutator, + final long doubledBitpos, final K key, + final io.usethesource.capsule.Set.Immutable valColl) { + final int idx = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = valColl; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + long updatedBitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_COLLECTION); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + AtomicReference mutator, long doubledBitpos, K key, + io.usethesource.capsule.Set.Immutable valColl) { + + final int idxOld = TUPLE_LENGTH * dataIndex(doubledBitpos); + final int idxNew = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) - 1 + collIndex(doubledBitpos)); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = key; + dst[idxNew + 1] = valColl; + System.arraycopy(src, idxNew + 2, dst, idxNew + 2, src.length - idxNew - 2); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_DATA_COLLECTION); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + AtomicReference mutator, long doubledBitpos, K key, V val) { + + // TODO: does not support src == dst yet for shifting + + final int idxOld = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + final int idxNew = TUPLE_LENGTH * dataIndex(doubledBitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' + assert idxNew <= idxOld; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = key; + dst[idxNew + 1] = val; + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 2, dst, idxOld + 2, src.length - idxOld - 2); + + long updatedBitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_SINGLETON); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(final AtomicReference mutator, + final long doubledBitpos) { + final int idx = TUPLE_LENGTH * dataIndex(doubledBitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + long updatedBitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_EMPTY); + return nodeOf(mutator, updatedBitmap, dst); + } + + // TODO: remove code duplication and merge with above + @Override + CompactSetMultimapNode copyAndRemoveSingleton(final AtomicReference mutator, + final long doubledBitpos, long updatedBitmap) { + final int idx = TUPLE_LENGTH * dataIndex(doubledBitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndRemoveCollection(final AtomicReference mutator, + final long doubledBitpos) { + final int idx = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + long updatedBitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_EMPTY); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToNode( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(doubledBitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(doubledBitpos); + + final Object[] dst = copyAndMigrateFromXxxToNode(idxOld, idxNew, node); + + long updatedBitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_NODE); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToNode(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + + final int idxOld = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(doubledBitpos); + + final Object[] dst = copyAndMigrateFromXxxToNode(idxOld, idxNew, node); + + long updatedBitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_NODE); + return nodeOf(mutator, updatedBitmap, dst); + } + + private Object[] copyAndMigrateFromXxxToNode(final int idxOld, final int idxNew, + final CompactSetMultimapNode node) { + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2 + 1]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 2, dst, idxNew + 1, src.length - idxNew - 2); + + return dst; + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(doubledBitpos); + final int idxNew = TUPLE_LENGTH * dataIndex(doubledBitpos); + + Object keyToInline = node.getSingletonKey(0); + Object valToInline = node.getSingletonValue(0); + + final Object[] dst = copyAndMigrateFromNodeToXxx(idxOld, idxNew, keyToInline, valToInline); + + long updatedBitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_SINGLETON); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToCollection(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(doubledBitpos); + final int idxNew = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + + Object keyToInline = node.getCollectionKey(0); + Object valToInline = node.getCollectionValue(0); + + final Object[] dst = copyAndMigrateFromNodeToXxx(idxOld, idxNew, keyToInline, valToInline); + + long updatedBitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_COLLECTION); + return nodeOf(mutator, updatedBitmap, dst); + } + + private Object[] copyAndMigrateFromNodeToXxx(final int idxOld, final int idxNew, + Object keyToInline, Object valToInline) { + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 2]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = keyToInline; + dst[idxNew + 1] = valToInline; + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 2, src.length - idxOld - 1); + + return dst; + } + + @Override + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + final long bitmap) { + return nodeOf(mutator, bitmap, nodes); + } + + @Override + int patternOfSingleton() { + assert this.sizePredicate() == SIZE_ONE; + + long bitmap = this.bitmap(); + + final int doubledMask = Long.numberOfTrailingZeros(bitmap) / 2 * 2; + final int pattern = pattern(bitmap, doubledMask); + + return pattern; + } + + @Override + State stateOfSingleton() { + assert this.sizePredicate() == SIZE_ONE; + + long bitmap = this.bitmap(); + + final int doubledMask = Long.numberOfTrailingZeros(bitmap) / 2 * 2; + final int pattern = pattern(bitmap, doubledMask); + + return toState(pattern); + } + + @Deprecated + @Override + EitherSingletonOrCollection.Type typeOfSingleton() { + final int pattern = patternOfSingleton(); + + if (pattern == PATTERN_DATA_SINGLETON) { + return EitherSingletonOrCollection.Type.SINGLETON; + } else { + return EitherSingletonOrCollection.Type.COLLECTION; + } + } + + } + + private static abstract class AbstractHashCollisionNode + extends CompactSetMultimapNode { + + // TODO: remove constructor and stored properties within CompactSetMultimapNode + AbstractHashCollisionNode() { + super(null, 0L); + } + + static final > AbstractHashCollisionNode of( + final int hash, final K key0, final VS valColl0, final K key1, final VS valColl1) { + return new HashCollisionNode<>(hash, key0, valColl0, key1, valColl1); + } + + private static final RuntimeException UOE_BOILERPLATE = new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + private static final Supplier UOE_FACTORY = + () -> new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + @Override + CompactSetMultimapNode copyAndSetSingletonValue(AtomicReference mutator, + long doubledBitpos, V val) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndSetCollectionValue(AtomicReference mutator, + long doubledBitpos, io.usethesource.capsule.Set.Immutable valColl) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndSetNode(AtomicReference mutator, long doubledBitpos, + CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndInsertSingleton(AtomicReference mutator, + long doubledBitpos, K key, V val) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + AtomicReference mutator, long doubledBitpos, K key, + io.usethesource.capsule.Set.Immutable valColl) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(AtomicReference mutator, + long doubledBitpos) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveCollection(AtomicReference mutator, + long doubledBitpos) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToNode(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToNode(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToCollection(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + long bitmap) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndInsertCollection(AtomicReference mutator, + long doubledBitpos, K key, io.usethesource.capsule.Set.Immutable valColl) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(AtomicReference mutator, + long doubledBitpos, long updatedBitmap) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + AtomicReference mutator, long doubledBitpos, K key, V val) { + throw UOE_FACTORY.get(); + } + + @Override + int emptyArity() { + throw UOE_FACTORY.get(); + } + + @Override + Type typeOfSingleton() { + throw UOE_FACTORY.get(); + } + + @Override + int patternOfSingleton() { + throw UOE_FACTORY.get(); + } + } + + private static final class HashCollisionNode extends AbstractHashCollisionNode { + + private final int hash; + private final List>> collisionContent; + + HashCollisionNode(final int hash, final K key0, + final io.usethesource.capsule.Set.Immutable valColl0, final K key1, + final io.usethesource.capsule.Set.Immutable valColl1) { + this(hash, Arrays.asList(entryOf(key0, valColl0), entryOf(key1, valColl1))); + } + + HashCollisionNode(final int hash, + final List>> collisionContent) { + this.hash = hash; + this.collisionContent = collisionContent; + } + + private static final RuntimeException UOE = new UnsupportedOperationException(); + + private static final Supplier UOE_NOT_YET_IMPLEMENTED_FACTORY = + () -> new UnsupportedOperationException("Not yet implemented @ HashCollisionNode."); + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + CompactSetMultimapNode getNode(int index) { + throw UOE; + } + + @Override + boolean hasPayload(EitherSingletonOrCollection.Type type) { + switch (type) { + case SINGLETON: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).findAny() + .isPresent(); + case COLLECTION: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).findAny() + .isPresent(); + } + throw new RuntimeException(); + } + + @Override + int payloadArity(EitherSingletonOrCollection.Type type) { + switch (type) { + case SINGLETON: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).count(); + case COLLECTION: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).count(); + } + throw new RuntimeException(); + } + + @Override + K getSingletonKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getKey(); + } + + @Override + V getSingletonValue(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getValue().stream().findAny().get(); + } + + @Override + K getCollectionKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getKey(); + } + + @Override + io.usethesource.capsule.Set.Immutable getCollectionValue(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getValue(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return collisionContent.size() * 2; + } + + @Override + Object getSlot(int index) { + if (index % 2 == 0) { + return collisionContent.get(index / 2).getKey(); + } else { + return collisionContent.get(index / 2).getValue(); + } + } + + @Override + boolean containsKey(K key, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny() + .isPresent(); + } + + @Override + boolean containsTuple(K key, V val, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) + && entry.getValue().containsEquivalent(val, cmp.toComparator())) + .findAny().isPresent(); + } + + @Override + Optional> findByKey(K key, int keyHash, int shift, + EqualityComparator cmp) { + throw UOE_NOT_YET_IMPLEMENTED_FACTORY.get(); + } + + @Override + CompactSetMultimapNode inserted(AtomicReference mutator, K key, V val, + int keyHash, int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + if (values.containsEquivalent(val, cmp.toComparator())) { + // contains key and value + details.unchanged(); + return this; + + } else { + // contains key but not value + + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = + values.__insertEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + // TODO does not check that remainder is unmodified + assert updatedCollisionContent.size() == collisionContent.size(); + assert updatedCollisionContent.contains(optionalTuple.get()) == false; + // assert updatedCollisionContent.contains(entryOf(key, values.__insertEquivalent(val, + // cmp.toComparator()))); + assert updatedCollisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) + && entry.getValue().containsEquivalent(val, cmp.toComparator())) + .findAny().isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder() + .add(entryOf(key, setOf(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + assert updatedCollisionContent.size() == collisionContent.size() + 1; + assert updatedCollisionContent.containsAll(collisionContent); + // assert updatedCollisionContent.contains(entryOf(key, setOf(val))); + assert updatedCollisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey()) + && Objects.equals(setOf(val), entry.getValue())).findAny().isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode updated(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key -> replace val anyways + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = values + .__insertEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + if (values.size() == 1) { + details.updated(values.stream().findAny().get()); // unbox singleton + } else { + details.updated(values); + } + + return new HashCollisionNode(hash, updatedCollisionContent); + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder() + .add(entryOf(key, setOf(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode removed(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + if (values.containsEquivalent(val, cmp.toComparator())) { + // contains key and value -> remove mapping + + final List>> updatedCollisionContent; + + if (values.size() == 1) { + updatedCollisionContent = collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry != optionalTuple.get()) + .collect(Collectors.toList()); + } else { + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = + values.__removeEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + } + + details.updated(val); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + details.unchanged(); + return this; + } + + @Override + State stateOfSingleton() { + return null; + } + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIteratorSlotHistogram { + + private static final int MAX_DEPTH = 7; + private static final int START_CATEGORY = PATTERN_DATA_SINGLETON; + + protected AbstractSetMultimapNode payloadNode; + protected int payloadCategoryCursor; + + protected int payloadCategoryOffset; + protected int payloadCategoryOffsetEnd; + + protected int payloadTotalOffsetEnd; + + private int stackLevel = -1; + private final int[] stackOfOffsetsAndOutOfBounds = new int[MAX_DEPTH * 2]; + private final AbstractSetMultimapNode[] stackOfNodes = + new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapNode topOfStackNode; + int nodeCursorAddress; + int nodeLengthAddress; + + AbstractSetMultimapIteratorSlotHistogram(AbstractSetMultimapNode rootNode) { + final int offsetNodesEnd = rootNode.slotArity(); + final int offsetNodes = offsetNodesEnd - rootNode.nodeArity(); + final int offsetPayload = 0; + + if (offsetNodes < offsetNodesEnd) { + pushNode(rootNode, offsetNodes, offsetNodesEnd); + } + + if (offsetPayload < offsetNodes) { + setPayloadNode(rootNode, offsetPayload, offsetNodes); + } + } + + private void pushNode(AbstractSetMultimapNode node, int offsetStart, int offsetEnd) { + if (stackLevel >= 0) { + // save current cursor + stackOfOffsetsAndOutOfBounds[stackLevel * 2] = nodeCursorAddress; + } + + final int nextStackLevel = ++stackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + stackOfNodes[nextStackLevel] = node; + stackOfOffsetsAndOutOfBounds[nextCursorIndex] = offsetStart; + stackOfOffsetsAndOutOfBounds[nextLengthIndex] = offsetEnd; + + // load next cursor + topOfStackNode = node; + nodeCursorAddress = offsetStart; + nodeLengthAddress = offsetEnd; + } + + private final void popNode() { + stackOfNodes[stackLevel--] = null; + + if (stackLevel >= 0) { + // load prevous cursor + final int previousStackLevel = stackLevel; + final int previousCursorIndex = previousStackLevel * 2; + final int previousLengthIndex = previousCursorIndex + 1; + + topOfStackNode = stackOfNodes[previousStackLevel]; + nodeCursorAddress = stackOfOffsetsAndOutOfBounds[previousCursorIndex]; + nodeLengthAddress = stackOfOffsetsAndOutOfBounds[previousLengthIndex]; + } + } + + private final AbstractSetMultimapNode consumeNode() { + AbstractSetMultimapNode nextNode = + (AbstractSetMultimapNode) topOfStackNode.getSlot(nodeCursorAddress++); + + if (nodeCursorAddress == nodeLengthAddress) { + popNode(); + } + + return nextNode; + } + + private void setPayloadNode(final AbstractSetMultimapNode node, int categoryOffsetStart, + int overallOffsetEnd) { + payloadNode = node; + payloadCategoryCursor = START_CATEGORY; + + payloadCategoryOffset = categoryOffsetStart; + payloadCategoryOffsetEnd = + categoryOffsetStart + (node.arity(START_CATEGORY) * AbstractSetMultimapNode.TUPLE_LENGTH); + + payloadTotalOffsetEnd = overallOffsetEnd; + } + + protected boolean searchNextPayloadCategory() { + do { + payloadCategoryOffsetEnd += + (payloadNode.arity(++payloadCategoryCursor) * AbstractSetMultimapNode.TUPLE_LENGTH); + } while (payloadCategoryOffset == payloadCategoryOffsetEnd); + + return true; + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + boolean found = false; + while (!found && stackLevel >= 0) { + final AbstractSetMultimapNode nextNode = consumeNode(); + + final int offsetNodesEnd = nextNode.slotArity(); + final int offsetNodes = offsetNodesEnd - nextNode.nodeArity(); + final int offsetPayload = 0; + + if (offsetNodes < offsetNodesEnd) { + pushNode(nextNode, offsetNodes, offsetNodesEnd); + } + + if (offsetPayload < offsetNodes) { + setPayloadNode(nextNode, offsetPayload, offsetNodes); + found = true; + } + } + + return found; + } + + protected boolean advanceToNext() { + return (payloadCategoryOffset < payloadTotalOffsetEnd && searchNextPayloadCategory()) + || searchNextValueNode(); + } + + public boolean hasNext() { + return payloadCategoryOffset < payloadCategoryOffsetEnd || advanceToNext(); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetMultimapKeyIteratorSlotHistogram + extends AbstractSetMultimapIteratorSlotHistogram implements Iterator { + + SetMultimapKeyIteratorSlotHistogram(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + switch (payloadCategoryCursor) { + case PATTERN_DATA_SINGLETON: + case PATTERN_DATA_COLLECTION: + int nextSlot = payloadCategoryOffset; + payloadCategoryOffset = nextSlot + 2; + + return (K) payloadNode.getSlot(nextSlot); + default: + throw new IllegalStateException(); + } + } + } + + } + + protected static class SetMultimapNativeTupleIteratorSlotHistogram extends + AbstractSetMultimapIteratorSlotHistogram implements Iterator> { + + SetMultimapNativeTupleIteratorSlotHistogram(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + switch (payloadCategoryCursor) { + case PATTERN_DATA_SINGLETON: + case PATTERN_DATA_COLLECTION: + int nextSlot = payloadCategoryOffset; + + K nextKey = (K) payloadNode.getSlot(nextSlot++); + // nextSlot += 1; + Object nextVal = payloadNode.getSlot(nextSlot++); + // nextSlot += 1; + + payloadCategoryOffset = nextSlot; + + return entryOf(nextKey, nextVal); + default: + throw new IllegalStateException(); + } + } + } + + } + + protected static class SetMultimapFlattenedTupleIteratorSlotHistogram + extends AbstractSetMultimapIteratorSlotHistogram implements Iterator> { + + private K cachedKey = null; + private Iterator cachedValueSetIterator = Collections.emptyIterator(); + + SetMultimapFlattenedTupleIteratorSlotHistogram(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public boolean hasNext() { + return cachedValueSetIterator.hasNext() || super.hasNext(); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + switch (payloadCategoryCursor) { + case PATTERN_DATA_SINGLETON: { + int nextSlot = payloadCategoryOffset; + + K nextKey = (K) payloadNode.getSlot(nextSlot++); + // nextSlot += 1; + V nextVal = (V) payloadNode.getSlot(nextSlot++); + // nextSlot += 1; + + payloadCategoryOffset = nextSlot; + + return entryOf(nextKey, nextVal); + } + case PATTERN_DATA_COLLECTION: { + if (cachedValueSetIterator.hasNext() == false) { + int nextSlot = payloadCategoryOffset; + + K nextKey = (K) payloadNode.getSlot(nextSlot++); + // nextSlot += 1; + io.usethesource.capsule.Set.Immutable nextValueSet = (io.usethesource.capsule.Set.Immutable) payloadNode + .getSlot(nextSlot++); + // nextSlot += 1; + + payloadCategoryOffset = nextSlot; + + cachedKey = nextKey; + cachedValueSetIterator = nextValueSet.iterator(); + } + + return entryOf(cachedKey, cachedValueSetIterator.next()); + } + default: + throw new IllegalStateException(); + } + } + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueSingletonCursor; + protected int currentValueSingletonLength; + protected int currentValueCollectionCursor; + protected int currentValueCollectionLength; + protected AbstractSetMultimapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractSetMultimapNode[] nodes = new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapIterator(AbstractSetMultimapNode rootNode) { + int nodeArity = rootNode.nodeArity(); + if (nodeArity != 0) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = nodeArity; + } + + int emptyArity = rootNode.emptyArity(); + if (emptyArity + nodeArity < 32) { + currentValueNode = rootNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = rootNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = rootNode.payloadArity(COLLECTION); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractSetMultimapNode nextNode = + nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + int nodeArity = nextNode.nodeArity(); + if (nodeArity != 0) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nodeArity; + } + + // int emptyArity = nextNode.emptyArity(); + // if (emptyArity + nodeArity < 32) { + if (nextNode.hasPayload(SINGLETON) || nextNode.hasPayload(COLLECTION)) { + // if (payloadAritySingleton != 0 || payloadArityCollection != 0) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = nextNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = nextNode.payloadArity(Type.COLLECTION); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueSingletonCursor < currentValueSingletonLength + || currentValueCollectionCursor < currentValueCollectionLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetMultimapKeyIterator extends AbstractSetMultimapIterator + implements Iterator { + + SetMultimapKeyIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return currentValueNode.getSingletonKey(currentValueSingletonCursor++); + } else { + return currentValueNode.getCollectionKey(currentValueCollectionCursor++); + } + } + } + + } + + protected static class SetMultimapValueIterator extends AbstractSetMultimapIterator + implements Iterator> { + + SetMultimapValueIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public io.usethesource.capsule.Set.Immutable next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return setOf(currentValueNode.getSingletonValue(currentValueSingletonCursor++)); + } else { + return currentValueNode.getCollectionValue(currentValueCollectionCursor++); + } + } + } + + } + + protected static class SetMultimapNativeTupleIterator + extends AbstractSetMultimapIterator implements Iterator> { + + SetMultimapNativeTupleIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + final K currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + final Object currentValue = + currentValueNode.getSingletonValue(currentValueSingletonCursor); + currentValueSingletonCursor++; + + return AbstractSpecialisedImmutableMap.entryOf(currentKey, currentValue); + } else { + final K currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + final Object currentValue = + currentValueNode.getCollectionValue(currentValueCollectionCursor); + currentValueCollectionCursor++; + + return AbstractSpecialisedImmutableMap.entryOf(currentKey, currentValue); + } + } + } + + } + + protected static class SetMultimapTupleIterator extends AbstractSetMultimapIterator + implements Iterator { + + final BiFunction tupleOf; + + K currentKey = null; + V currentValue = null; + Iterator currentSetIterator = Collections.emptyIterator(); + + SetMultimapTupleIterator(AbstractSetMultimapNode rootNode, + final BiFunction tupleOf) { + super(rootNode); + this.tupleOf = tupleOf; + } + + @Override + public boolean hasNext() { + if (currentSetIterator.hasNext()) { + return true; + } else { + if (super.hasNext()) { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + currentSetIterator = Collections + .singleton(currentValueNode.getSingletonValue(currentValueSingletonCursor)) + .iterator(); + currentValueSingletonCursor++; + } else { + currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + currentSetIterator = + currentValueNode.getCollectionValue(currentValueCollectionCursor).iterator(); + currentValueCollectionCursor++; + } + + return true; + } else { + return false; + } + } + } + + @Override + public T next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + currentValue = currentSetIterator.next(); + return tupleOf.apply(currentKey, currentValue); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieSetMultimap_BleedingEdgeNodeIterator + implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieSetMultimap_BleedingEdgeNodeIterator(AbstractSetMultimapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractSetMultimapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieSetMultimap_BleedingEdge + implements SetMultimap.Transient { + + private final EqualityComparator cmp; + + final private AtomicReference mutator; + private AbstractSetMultimapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieSetMultimap_BleedingEdge( + TrieSetMultimap_HHAMT trieSetMultimap_BleedingEdge) { + this.cmp = trieSetMultimap_BleedingEdge.cmp; + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieSetMultimap_BleedingEdge.rootNode; + this.hashCode = trieSetMultimap_BleedingEdge.hashCode; + this.cachedSize = trieSetMultimap_BleedingEdge.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.equals(iterator.next(), o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get().contains(val); + } else { + return false; + } + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public boolean __put(K key, io.usethesource.capsule.Set.Immutable valColl) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + // if (valColl.size() == 1) { + // throw new IllegalStateException(); + // } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.updated(null, key, valColl, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = valColl.hashCode(); + + rootNode = newRootNode; + // hashCode += 0; + // cachedSize += 0; + + // return new TrieSetMultimap_HHAMT(cmp, newRootNode, + // hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + + throw new IllegalStateException(); + // + // return true; + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + final int valHashNew = valColl.hashCode(); + + rootNode = newRootNode; + // hashCode += 0; + // cachedSize += 0; + + // return new TrieSetMultimap_HHAMT(cmp, newRootNode, + // hashCode + ((keyHash ^ valHashNew)) - sumOfReplacedHashes, + // cachedSize - details.getReplacedCollection().size() + 1); + + throw new IllegalStateException(); + // + // return true; + } + } + + int sumOfNewHashes = 0; + + // for (V newValue : valColl) { + // sumOfNewHashes += (keyHash ^ newValue.hashCode()); + // } + + rootNode = newRootNode; + hashCode += sumOfNewHashes; + cachedSize += valColl.size(); + + // final int valHash = valColl.hashCode(); + // return new TrieSetMultimap_HHAMT(cmp, newRootNode, hashCode + ((keyHash ^ + // valHash)), + // cachedSize + 1); + + return true; + } + + return false; + } + + @Override + public boolean __insert(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + /* + * TODO: Fix __put(K key, Immutable valColl) for batch insertion and re-enabled + * fast-fail check. + */ + // final int valHashNew = val.hashCode(); + rootNode = newRootNode; + // hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean union(final SetMultimap setMultimap) { + boolean modified = false; + + for (Map.Entry entry : setMultimap.entrySet()) { + modified |= this.__insert(entry.getKey(), entry.getValue()); + } + + return modified; + } + + @Override + public boolean __remove(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return false; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new TransientSetMultimapKeyIterator<>(this); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(Set::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + return new TransientSetMultimapTupleIterator<>(this, + AbstractSpecialisedImmutableMap::entryOf); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new TransientSetMultimapTupleIterator<>(this, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + public static class TransientSetMultimapKeyIterator extends SetMultimapKeyIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + K lastKey; + + public TransientSetMultimapKeyIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapValueIterator + extends SetMultimapValueIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapValueIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public io.usethesource.capsule.Set.Immutable next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapTupleIterator + extends SetMultimapTupleIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapTupleIterator( + final TransientTrieSetMultimap_BleedingEdge collection, + final BiFunction tupleOf) { + super(collection.rootNode, tupleOf); + this.collection = collection; + } + + @Override + public T next() { + return super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(currentKey, currentValue); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieSetMultimap_BleedingEdge.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieSetMultimap_BleedingEdge) { + TransientTrieSetMultimap_BleedingEdge that = + (TransientTrieSetMultimap_BleedingEdge) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + /* + * TODO: Fix __put(K key, Immutable valColl) for batch insertion and re-enabled + * fast-fail check. + */ + // if (this.hashCode != that.hashCode) { + // return false; + // } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + final io.usethesource.capsule.Set.Immutable valColl = (io.usethesource.capsule.Set.Immutable) entry + .getValue(); + + if (!cmp.equals(result.get(), valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public SetMultimap.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieSetMultimap_HHAMT(cmp, rootNode, hashCode, cachedSize); + } + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Interlinked.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Interlinked.java new file mode 100644 index 0000000..9a5a7b4 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Interlinked.java @@ -0,0 +1,3855 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.multimap; + +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Deque; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import io.usethesource.capsule.SetMultimap; +import io.usethesource.capsule.core.PersistentTrieSet.AbstractSetNode; +import io.usethesource.capsule.core.PersistentTrieSet.SetResult; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Interlinked.EitherSingletonOrCollection.Type; +import io.usethesource.capsule.util.EqualityComparator; +import io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap; + +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_DATA_COLLECTION; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_DATA_SINGLETON; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_EMPTY; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_NODE; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setBitPattern; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setFromNode; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setNodeOf; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setOf; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setToNode; +import static io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Interlinked.EitherSingletonOrCollection.Type.COLLECTION; +import static io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Interlinked.EitherSingletonOrCollection.Type.SINGLETON; +import static io.usethesource.capsule.util.BitmapUtils.filter; +import static io.usethesource.capsule.util.BitmapUtils.index; +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +public class TrieSetMultimap_HHAMT_Interlinked implements SetMultimap.Immutable { + + private final EqualityComparator cmp; + + private static final TrieSetMultimap_HHAMT_Interlinked EMPTY_SETMULTIMAP = + new TrieSetMultimap_HHAMT_Interlinked(EqualityComparator.EQUALS, + CompactSetMultimapNode.EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractSetMultimapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieSetMultimap_HHAMT_Interlinked(EqualityComparator cmp, + AbstractSetMultimapNode rootNode, int hashCode, int cachedSize) { + this.cmp = cmp; + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final SetMultimap.Immutable of() { + return TrieSetMultimap_HHAMT_Interlinked.EMPTY_SETMULTIMAP; + } + + public static final SetMultimap.Immutable of(EqualityComparator cmp) { + // TODO: unify with `of()` + return new TrieSetMultimap_HHAMT_Interlinked(cmp, CompactSetMultimapNode.EMPTY_NODE, 0, 0); + } + + public static final SetMultimap.Immutable of(K key, V... values) { + SetMultimap.Immutable result = TrieSetMultimap_HHAMT_Interlinked.EMPTY_SETMULTIMAP; + + for (V value : values) { + result = result.__insert(key, value); + } + + return result; + } + + public static final SetMultimap.Transient transientOf() { + return TrieSetMultimap_HHAMT_Interlinked.EMPTY_SETMULTIMAP.asTransient(); + } + + public static final SetMultimap.Transient transientOf(K key, V... values) { + final SetMultimap.Transient result = + TrieSetMultimap_HHAMT_Interlinked.EMPTY_SETMULTIMAP.asTransient(); + + for (V value : values) { + result.__insert(key, value); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.equals(iterator.next(), o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + return rootNode.containsTuple(key, val, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return setFromNode(result.get()); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public SetMultimap.Immutable __put(K key, V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieSetMultimap_HHAMT_Interlinked(cmp, newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + final int valHashNew = val.hashCode(); + + return new TrieSetMultimap_HHAMT_Interlinked(cmp, newRootNode, + hashCode + ((keyHash ^ valHashNew)) - sumOfReplacedHashes, + cachedSize - details.getReplacedCollection().size() + 1); + } + } + + final int valHash = val.hashCode(); + return new TrieSetMultimap_HHAMT_Interlinked(cmp, newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable __insert(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + final int valHash = val.hashCode(); + return new TrieSetMultimap_HHAMT_Interlinked(cmp, newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable union( + final SetMultimap setMultimap) { + final SetMultimap.Transient tmpTransient = this.asTransient(); + tmpTransient.union(setMultimap); + return tmpTransient.freeze(); + } + + @Override + public SetMultimap.Immutable __remove(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap_HHAMT_Interlinked(cmp, newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable __remove(K key) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removedAll(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap_HHAMT_Interlinked(cmp, newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + return new TrieSetMultimap_HHAMT_Interlinked(cmp, newRootNode, + hashCode - sumOfReplacedHashes, cachedSize - details.getReplacedCollection().size()); + } + } + + return this; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new SetMultimapKeyIterator<>(rootNode); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(AbstractSetNode::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + return new SetMultimapTupleIterator<>(rootNode, AbstractSpecialisedImmutableMap::entryOf); + } + + @Override + public Iterator> nativeEntryIterator() { + return new SetMultimapNativeTupleIterator<>(rootNode); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new SetMultimapTupleIterator<>(rootNode, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieSetMultimap_HHAMT_Interlinked.this.keyIterator(); + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT_Interlinked.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT_Interlinked.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieSetMultimap_HHAMT_Interlinked.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieSetMultimap_HHAMT_Interlinked.this.valueIterator(); + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT_Interlinked.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT_Interlinked.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TrieSetMultimap_HHAMT_Interlinked.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT_Interlinked.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT_Interlinked.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieSetMultimap_HHAMT_Interlinked.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieSetMultimap_HHAMT_Interlinked) { + TrieSetMultimap_HHAMT_Interlinked that = + (TrieSetMultimap_HHAMT_Interlinked) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + /* + * TODO: Fix __put(K key, AbstractSetNode valColl) for batch insertion and re-enabled + * fast-fail check. + */ + // if (this.hashCode != that.hashCode) { + // return false; + // } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + final AbstractSetNode valColl = (AbstractSetNode) entry.getValue(); + + if (!cmp.equals(result.get(), valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public SetMultimap.Transient asTransient() { + return new TransientTrieSetMultimap_BleedingEdge(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractSetMultimapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieSetMultimap_BleedingEdgeNodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + // /* + // * For analysis purposes only. Payload X Node + // */ + // protected int[][] arityCombinationsHistogram() { + // final Iterator> it = nodeIterator(); + // final int[][] sumArityCombinations = new int[33][33]; + // + // while (it.hasNext()) { + // final AbstractSetMultimapNode node = it.next(); + // sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + // } + // + // return sumArityCombinations; + // } + // + // /* + // * For analysis purposes only. + // */ + // protected int[] arityHistogram() { + // final int[][] sumArityCombinations = arityCombinationsHistogram(); + // final int[] sumArity = new int[33]; + // + // final int maxArity = 32; // TODO: factor out constant + // + // for (int j = 0; j <= maxArity; j++) { + // for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + // sumArity[j + k] += sumArityCombinations[j][k]; + // } + // } + // + // return sumArity; + // } + // + // /* + // * For analysis purposes only. + // */ + // public void printStatistics() { + // final int[][] sumArityCombinations = arityCombinationsHistogram(); + // final int[] sumArity = arityHistogram(); + // final int sumNodes = getNodeCount(); + // + // final int[] cumsumArity = new int[33]; + // for (int cumsum = 0, i = 0; i < 33; i++) { + // cumsum += sumArity[i]; + // cumsumArity[i] = cumsum; + // } + // + // final float threshhold = 0.01f; // for printing results + // for (int i = 0; i < 33; i++) { + // float arityPercentage = (float) (sumArity[i]) / sumNodes; + // float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + // + // if (arityPercentage != 0 && arityPercentage >= threshhold) { + // // details per level + // StringBuilder bldr = new StringBuilder(); + // int max = i; + // for (int j = 0; j <= max; j++) { + // for (int k = max - j; k <= max - j; k++) { + // float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + // + // if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + // bldr.append(String.format("%d/%d: %s, ", j, k, + // new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + // } + // } + // } + // final String detailPercentages = bldr.toString(); + // + // // overview + // System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + // new DecimalFormat("0.00%").format(arityPercentage), + // new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + // } + // } + // } + + static abstract class EitherSingletonOrCollection { + + public enum Type { + SINGLETON, COLLECTION + } + + public static final EitherSingletonOrCollection of(T value) { + return new SomeSingleton<>(value); + } + + public static final EitherSingletonOrCollection of(AbstractSetNode value) { + return new SomeCollection<>(value); + } + + abstract boolean isType(Type type); + + abstract T getSingleton(); + + abstract AbstractSetNode getCollection(); + } + + static final class SomeSingleton extends EitherSingletonOrCollection { + + private final T value; + + private SomeSingleton(T value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.SINGLETON; + } + + @Override + T getSingleton() { + return value; + } + + @Override + AbstractSetNode getCollection() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.COLLECTION, Type.SINGLETON)); + } + } + + static final class SomeCollection extends EitherSingletonOrCollection { + + private final AbstractSetNode value; + + private SomeCollection(AbstractSetNode value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.COLLECTION; + } + + @Override + T getSingleton() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.SINGLETON, Type.COLLECTION)); + } + + @Override + AbstractSetNode getCollection() { + return value; + } + } + + static final class SetMultimapResult { + + private V replacedValue; + private AbstractSetNode replacedValueCollection; + private EitherSingletonOrCollection.Type replacedType; + + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(V replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + this.replacedType = SINGLETON; + } + + public void updated(AbstractSetNode replacedValueCollection) { + this.replacedValueCollection = replacedValueCollection; + this.isModified = true; + this.isReplaced = true; + this.replacedType = COLLECTION; + } + + // update: neither element, nor element count changed + public static SetMultimapResult unchanged() { + return new SetMultimapResult<>(); + } + + private SetMultimapResult() { + } + + public boolean isModified() { + return isModified; + } + + public EitherSingletonOrCollection.Type getType() { + return replacedType; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public V getReplacedValue() { + assert getType() == SINGLETON; + return replacedValue; + } + + public AbstractSetNode getReplacedCollection() { + assert getType() == COLLECTION; + return replacedValueCollection; + } + } + + protected static interface INode { + + } + + protected static abstract class AbstractSetMultimapNode implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract boolean containsTuple(final K key, final V val, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract Optional> findByKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract CompactSetMultimapNode inserted(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode updated(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode updated(final AtomicReference mutator, + final K key, final AbstractSetNode val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode removed(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode removedAll(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractSetMultimapNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractSetMultimapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractSetMultimapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract int emptyArity(); + + // @Deprecated // split data / coll arity + // abstract boolean hasPayload(); + // + // @Deprecated // split data / coll arity + // abstract int payloadArity(); + + abstract boolean hasPayload(EitherSingletonOrCollection.Type type); + + // abstract int payloadArity(); + + abstract int payloadArity(EitherSingletonOrCollection.Type type); + + abstract K getSingletonKey(final int index); + + abstract V getSingletonValue(final int index); + + abstract K getCollectionKey(final int index); + + abstract AbstractSetNode getCollectionValue(final int index); + + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + abstract int arity(); + + int size() { + final Iterator it = new SetMultimapKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactSetMultimapNode + extends AbstractSetMultimapNode { + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + static final int doubledMask(int keyHash, int shift) { + final int mask = mask(keyHash, shift); + return mask << 1; + } + + static final long doubledBitpos(final int doubledMask) { + return 1L << doubledMask; + } + + static final int pattern(long bitmap, int doubledMask) { + return (int) ((bitmap >>> doubledMask) & 0b11); + } + + // @Deprecated + // abstract int dataMap(); + // + // @Deprecated + // abstract int collMap(); + // + // @Deprecated + // abstract int nodeMap(); + + abstract long bitmap(); + + @Deprecated + @Override + int arity() { + // TODO: replace with 32 - arity(emptyMap) + // return arity(bitmap(), PATTERN_DATA_SINGLETON) + arity(bitmap(), PATTERN_DATA_COLLECTION) + + // arity(bitmap(), PATTERN_NODE); + + int[] arities = arities(bitmap()); + return Arrays.stream(arities).skip(1).sum(); + } + + static final int arity(long bitmap, int pattern) { + if (bitmap == 0) { + if (pattern == PATTERN_EMPTY) { + return 32; + } else { + return 0; + } + } else { + return Long.bitCount(filter(bitmap, pattern)); + } + } + + // TODO: Implement arity histogram over bitmap (with single for loop) that calculates offsets + static final int[] arities(final long bitmap) { + int[] arities = new int[4]; + + long shiftedBitmap = bitmap; + for (int i = 0; i < 32; i++) { + arities[(int) shiftedBitmap & 0b11]++; + shiftedBitmap = shiftedBitmap >>> 2; + } + + return arities; + } + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactSetMultimapNode getNode(final int index); + + boolean nodeInvariant() { + return true; + // boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + // boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + // boolean inv3 = + // (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + // boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + // + // boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + // && ((this.payloadArity() + this.nodeArity()) == this.arity()); + // + // return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + final long bitmap); + + abstract CompactSetMultimapNode copyAndSetSingletonValue( + final AtomicReference mutator, final long doubledBitpos, final V val); + + abstract CompactSetMultimapNode copyAndSetCollectionValue( + final AtomicReference mutator, final long doubledBitpos, + final AbstractSetNode valColl); + + abstract CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final long doubledBitpos, final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndInsertSingleton( + final AtomicReference mutator, final long doubledBitpos, final K key, final V val); + + abstract CompactSetMultimapNode copyAndInsertCollection( + final AtomicReference mutator, final long doubledBitpos, final K key, + final AbstractSetNode valColl); + + abstract CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + final AtomicReference mutator, final long doubledBitpos, final K key, + final AbstractSetNode valColl); + + abstract CompactSetMultimapNode copyAndRemoveSingleton( + final AtomicReference mutator, final long doubledBitpos); + + abstract CompactSetMultimapNode copyAndRemoveSingleton( + final AtomicReference mutator, final long doubledBitpos, long updatedBitmap); + + /* + * Batch updated, necessary for removedAll. + */ + abstract CompactSetMultimapNode copyAndRemoveCollection( + final AtomicReference mutator, final long doubledBitpos); + + abstract CompactSetMultimapNode copyAndMigrateFromSingletonToNode( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndMigrateFromNodeToSingleton( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node); // node get's unwrapped inside method + + abstract CompactSetMultimapNode copyAndMigrateFromCollectionToNode( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node); + + abstract CompactSetMultimapNode copyAndMigrateFromNodeToCollection( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node); // node get's unwrapped inside method + + abstract CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + final AtomicReference mutator, final long doubledBitpos, final K key, final V val); + + // TODO: fix hash collision support + static final CompactSetMultimapNode mergeTwoSingletonPairs(final K key0, + final V val0, final int keyHash0, final K key1, final V val1, final int keyHash1, + final int shift, EqualityComparator cmp) { + assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode.of(keyHash0, key0, setOf(val0), key1, setOf(val1)); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_SINGLETON); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_SINGLETON); + + if (mask0 < mask1) { + return nodeOf(null, bitmap, new Object[]{key0, val0, key1, val1}); + } else { + return nodeOf(null, bitmap, new Object[]{key1, val1, key0, val0}); + } + } else { + final CompactSetMultimapNode node = mergeTwoSingletonPairs(key0, val0, keyHash0, key1, + val1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf(null, bitmap, new Object[]{node}); + } + } + + // TODO: fix hash collision support + static final CompactSetMultimapNode mergeTwoCollectionPairs(final K key0, + final AbstractSetNode valColl0, final int keyHash0, final K key1, + final AbstractSetNode valColl1, final int keyHash1, final int shift, + EqualityComparator cmp) { + assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode + .of(keyHash0, key0, setFromNode(valColl0), key1, setFromNode(valColl1)); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_COLLECTION); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_COLLECTION); + + if (mask0 < mask1) { + return nodeOf(null, bitmap, new Object[]{key0, valColl0, key1, valColl1}); + } else { + return nodeOf(null, bitmap, new Object[]{key1, valColl1, key0, valColl0}); + } + } else { + final CompactSetMultimapNode node = mergeTwoCollectionPairs(key0, valColl0, keyHash0, + key1, valColl1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf(null, bitmap, new Object[]{node}); + } + } + + // TODO: fix hash collision support + static final CompactSetMultimapNode mergeCollectionAndSingletonPairs(final K key0, + final AbstractSetNode valColl0, final int keyHash0, final K key1, final V val1, + final int keyHash1, final int shift, EqualityComparator cmp) { + assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode + .of(keyHash0, key0, setFromNode(valColl0), key1, setOf(val1)); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_COLLECTION); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_SINGLETON); + + // singleton before collection + return nodeOf(null, bitmap, new Object[]{key1, val1, key0, valColl0}); + } else { + final CompactSetMultimapNode node = mergeCollectionAndSingletonPairs(key0, valColl0, + keyHash0, key1, val1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf(null, bitmap, new Object[]{node}); + } + } + + static final CompactSetMultimapNode EMPTY_NODE; + + static { + EMPTY_NODE = new BitmapIndexedSetMultimapNode<>(null, 0L, new Object[]{}); + } + + ; + + static final CompactSetMultimapNode nodeOf(final AtomicReference mutator, + final long bitmap, final Object[] nodes) { + return new BitmapIndexedSetMultimapNode<>(mutator, bitmap, nodes); + } + + static final CompactSetMultimapNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactSetMultimapNode nodeOf(AtomicReference mutator, + final long bitmap, final K key, final AbstractSetNode valColl) { + return nodeOf(mutator, bitmap, new Object[]{key, valColl}); + } + + // static final int index(final int bitmap, final int bitpos) { + // return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + // } + // + // static final int index(final int bitmap, final int mask, final int bitpos) { + // return (bitmap == -1) ? mask : index(bitmap, bitpos); + // } + + @Deprecated + int dataIndex(final long doubledBitpos) { + return index(bitmap(), PATTERN_DATA_SINGLETON, doubledBitpos); + } + + @Deprecated + int collIndex(final long doubledBitpos) { + return index(bitmap(), PATTERN_DATA_COLLECTION, doubledBitpos); + } + + @Deprecated + int nodeIndex(final long doubledBitpos) { + return index(bitmap(), PATTERN_NODE, doubledBitpos); + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + return cmp.equals(getSingletonKey(index), key); + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + return cmp.equals(getCollectionKey(index), key); + } + default: + return false; + } + } + + @Override + boolean containsTuple(final K key, final V val, final int keyHash, final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + + final AbstractSetMultimapNode subNode = getNode(index); + return subNode.containsTuple(key, val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(index); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(index); + return cmp.equals(currentVal, val); + } + + return false; + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(index); + if (cmp.equals(currentKey, key)) { + + final AbstractSetNode currentValColl = getCollectionValue(index); + return currentValColl.contains(val, val.hashCode(), 0); + } + + return false; + } + default: + return false; + } + } + + @Override + Optional> findByKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + + final AbstractSetMultimapNode subNode = getNode(index); + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(index); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(index); + return Optional.of(setNodeOf(currentVal)); + } + + return Optional.empty(); + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(index); + if (cmp.equals(currentKey, key)) { + + final AbstractSetNode currentValColl = getCollectionValue(index); + return Optional.of(currentValColl); + } + + return Optional.empty(); + } + default: + return Optional.empty(); + } + } + + @Override + CompactSetMultimapNode inserted(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = subNode.inserted(mutator, key, val, + keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + if (cmp.equals(currentVal, val)) { + return this; + } else { + // migrate from singleton to collection + final AbstractSetNode valColl = setNodeOf(currentVal, val); + + details.modified(); + return copyAndMigrateFromSingletonToCollection(mutator, doubledBitpos, currentKey, + valColl); + } + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final AbstractSetNode currentCollVal = getCollectionValue(collIndex); + + if (currentCollVal.contains(val, val.hashCode(), 0)) { + return this; + } else { + // add new mapping + final AbstractSetNode newCollVal = + currentCollVal.updated(mutator, val, val.hashCode(), 0, SetResult.unchanged()); + + details.modified(); + return copyAndSetCollectionValue(mutator, doubledBitpos, newCollVal); + } + } else { + // prefix-collision (case: collection x singleton) + final AbstractSetNode currentValNode = getCollectionValue(collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertSingleton(mutator, doubledBitpos, key, val); + } + } + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + // update singleton value + details.updated(currentVal); + return copyAndSetSingletonValue(mutator, doubledBitpos, val); + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final AbstractSetNode currentCollVal = getCollectionValue(collIndex); + + // migrate from collection to singleton + details.updated(currentCollVal); + return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, currentCollKey, + val); + } else { + // prefix-collision (case: collection x singleton) + final AbstractSetNode currentValNode = getCollectionValue(collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertSingleton(mutator, doubledBitpos, key, val); + } + } + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final AbstractSetNode valColl, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = subNode.updated(mutator, key, valColl, + keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + // migrate from singleton to collection + details.updated(currentVal); + return copyAndMigrateFromSingletonToCollection(mutator, doubledBitpos, currentKey, + valColl); + // + // + // // update singleton value + // details.updated(currentVal); + // return copyAndSetSingletonValue(mutator, doubledBitpos, valColl); + } else { + // prefix-collision (case: collection x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = + mergeCollectionAndSingletonPairs(key, valColl, keyHash, currentKey, currentVal, + transformHashCode(currentKey.hashCode()), shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, subNodeNew); + + // // prefix-collision (case: singleton x singleton) + // final V currentVal = getSingletonValue(dataIndex); + // + // final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + // currentVal, transformHashCode(currentKey.hashCode()), key, valColl, keyHash, + // shift + BIT_PARTITION_SIZE, cmp); + // + // details.modified(); + // return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final AbstractSetNode currentCollVal = getCollectionValue(collIndex); + + // update collection value + details.updated(currentCollVal); + return copyAndSetCollectionValue(mutator, doubledBitpos, valColl); + + // // migrate from collection to singleton + // details.updated(currentCollVal); + // return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, + // currentCollKey, + // valColl); + } else { + // prefix-collision (case: collection x collection) + final AbstractSetNode currentValNode = getCollectionValue(collIndex); + final CompactSetMultimapNode subNodeNew = mergeTwoCollectionPairs(currentCollKey, + currentValNode, transformHashCode(currentCollKey.hashCode()), key, valColl, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, subNodeNew); + + // // prefix-collision (case: collection x singleton) + // final AbstractSetNode currentValNode = getCollectionValue(collIndex); + // final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + // currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + // valColl, keyHash, shift + BIT_PARTITION_SIZE, cmp); + // + // details.modified(); + // return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertCollection(mutator, doubledBitpos, key, valColl); + } + } + } + + @Override + CompactSetMultimapNode removed(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.removed(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (slotArity() == 0) { + if (shift == 0) { + // singleton remaining + final long doubledBitposAtShift0 = doubledBitpos(bitpos(doubledMask(keyHash, 0))); + + final long updatedBitmapAtShift0 = + setBitPattern(doubledBitposAtShift0, subNodeNew.patternOfSingleton()); + + return subNodeNew.copyAndUpdateBitmaps(mutator, updatedBitmapAtShift0); + } else { + // escalate (singleton or empty) result + return subNodeNew; + } + } else { + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + } + + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(dataIndex); + if (cmp.equals(currentVal, val)) { + + // remove mapping + details.updated(val); + return copyAndRemoveSingleton(mutator, doubledBitpos); + } else { + return this; + } + } else { + return this; + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(collIndex); + if (cmp.equals(currentKey, key)) { + + final AbstractSetNode currentValColl = getCollectionValue(collIndex); + if (currentValColl.contains(val, val.hashCode(), 0)) { + + // remove mapping + details.updated(val); + + final AbstractSetNode newValColl = + currentValColl.removed(mutator, val, val.hashCode(), 0, SetResult.unchanged()); + + if (newValColl.size() == 1) { + // TODO: investigate options for unboxing singleton collections + V remainingVal = newValColl.iterator().next(); + return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, key, + remainingVal); + } else { + return copyAndSetCollectionValue(mutator, doubledBitpos, newValColl); + } + } else { + return this; + } + } else { + return this; + } + } + default: + return this; + } + } + + final static boolean hasSingleNode(int[] arities) { + return arities[PATTERN_EMPTY] == 31 && arities[PATTERN_NODE] == 1; + } + + final static boolean hasTwoPayloads(int[] arities) { + return arities[PATTERN_EMPTY] == 30 && arities[PATTERN_NODE] == 0; + } + + enum State { + EMPTY, NODE, PAYLOAD, PAYLOAD_RARE + } + + static final State toState(final int pattern) { + // final State[] states = {State.EMPTY, State.NODE, State.PAYLOAD, State.PAYLOAD_RARE}; + // return states[pattern]; + + switch (pattern) { + case PATTERN_EMPTY: + return State.EMPTY; + case PATTERN_NODE: + return State.NODE; + case PATTERN_DATA_SINGLETON: + return State.PAYLOAD; + default: + return State.PAYLOAD_RARE; + } + } + + @Override + CompactSetMultimapNode removedAll(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.removedAll(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (slotArity() == 1) { + if (shift == 0) { + // singleton remaining + final long doubledBitposAtShift0 = doubledBitpos(bitpos(doubledMask(keyHash, 0))); + + final long updatedBitmapAtShift0 = + setBitPattern(doubledBitposAtShift0, subNodeNew.patternOfSingleton()); + + return subNodeNew.copyAndUpdateBitmaps(mutator, updatedBitmapAtShift0); + } else { + // escalate (singleton or empty) result + return subNodeNew; + } + } else { + // // inline value (move to front) + // final State subNodeState = subNodeNew.stateOfSingleton(); + // + //// switch (subNodeState) { + //// case EMPTY: + //// case NODE: + //// case PAYLOAD: + //// return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + //// case PAYLOAD_RARE: + //// return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + //// } + // + // if (subNodeState == State.PAYLOAD) { + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // } else { + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // } + + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + } + + // // inline value (move to front) + // final int subNodePattern = subNodeNew.patternOfSingleton(); + // + // if (subNodePattern == PATTERN_DATA_SINGLETON) { + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // } else { + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // } + + // switch (subNodePattern) { + // case PATTERN_DATA_SINGLETON: + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // case PATTERN_DATA_COLLECTION: + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // default: + // return null; + // } + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, doubledBitpos, subNodeNew); + } + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(dataIndex); + + details.updated(currentVal); + return copyAndRemoveSingleton(mutator, doubledBitpos); + } else { + return this; + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(collIndex); + if (cmp.equals(currentKey, key)) { + + final AbstractSetNode currentValColl = getCollectionValue(collIndex); + + details.updated(currentValColl); + return copyAndRemoveCollection(mutator, doubledBitpos); + } else { + return this; + } + } + default: + return this; + } + } + + abstract int patternOfSingleton(); + + @Deprecated + abstract EitherSingletonOrCollection.Type typeOfSingleton(); + + @Deprecated + abstract State stateOfSingleton(); + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + long bitmap = this.bitmap(); + + int[] arities = arities(bitmap); + + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < arities[PATTERN_DATA_SINGLETON]; i++) { + final byte pos = -1; // TODO: recoverMask(dataMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getSingletonKey(i)), + Objects.hashCode(getSingletonValue(i)))); + + if (!((i + 1) == arities[PATTERN_DATA_SINGLETON])) { + bldr.append(", "); + } + } + + if (arities[PATTERN_DATA_SINGLETON] > 0 && arities[PATTERN_DATA_COLLECTION] > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arities[PATTERN_DATA_COLLECTION]; i++) { + final byte pos = -1; // TODO: recoverMask(collMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getCollectionKey(i)), + Objects.hashCode(getCollectionValue(i)))); + + if (!((i + 1) == arities[PATTERN_DATA_COLLECTION])) { + bldr.append(", "); + } + } + + if (arities[PATTERN_DATA_COLLECTION] > 0 && arities[PATTERN_NODE] > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arities[PATTERN_NODE]; i++) { + final byte pos = -1; // TODO: recoverMask(nodeMap, (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == arities[PATTERN_NODE])) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedSetMultimapNode + extends CompactSetMultimapNode { + + private final long bitmap; + + CompactMixedSetMultimapNode(final AtomicReference mutator, final long bitmap) { + this.bitmap = bitmap; + } + + @Override + public long bitmap() { + return bitmap; + } + + // @Override + // int dataMap() { + // return rawMap2() ^ collMap(); + // } + // + // @Override + // int collMap() { + // return rawMap1() & rawMap2(); + // } + // + // @Override + // int nodeMap() { + // return rawMap1() ^ collMap(); + // } + + } + + private static final class BitmapIndexedSetMultimapNode + extends CompactMixedSetMultimapNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedSetMultimapNode(final AtomicReference mutator, final long bitmap, + final Object[] nodes) { + super(mutator, bitmap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + int[] arities = arities(bitmap); + + assert (TUPLE_LENGTH * arities[PATTERN_DATA_SINGLETON] + + TUPLE_LENGTH * arities[PATTERN_DATA_COLLECTION] + + arities[PATTERN_NODE] == nodes.length); + + for (int i = 0; i < arities[PATTERN_DATA_SINGLETON]; i++) { + int offset = i * TUPLE_LENGTH; + + assert ((nodes[offset + 0] instanceof AbstractSetNode) == false); + assert ((nodes[offset + 1] instanceof AbstractSetNode) == false); + + assert ((nodes[offset + 0] instanceof CompactSetMultimapNode) == false); + assert ((nodes[offset + 1] instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arities[PATTERN_DATA_COLLECTION]; i++) { + int offset = (i + arities[PATTERN_DATA_SINGLETON]) * TUPLE_LENGTH; + + assert ((nodes[offset + 0] instanceof AbstractSetNode) == false); + assert ((nodes[offset + 1] instanceof AbstractSetNode) == true); + + assert ((nodes[offset + 0] instanceof CompactSetMultimapNode) == false); + assert ((nodes[offset + 1] instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arities[PATTERN_NODE]; i++) { + int offset = + (arities[PATTERN_DATA_SINGLETON] + arities[PATTERN_DATA_COLLECTION]) * TUPLE_LENGTH; + + assert ((nodes[offset + i] instanceof AbstractSetNode) == false); + + assert ((nodes[offset + i] instanceof CompactSetMultimapNode) == true); + } + } + + assert nodeInvariant(); + } + + @Override + K getSingletonKey(final int index) { + return (K) nodes[TUPLE_LENGTH * index]; + } + + @Override + V getSingletonValue(int index) { + return (V) nodes[TUPLE_LENGTH * index + 1]; + } + + @Override + K getCollectionKey(int index) { + // TODO: improve on offset calculation (caching it, etc) + int offset = TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + index); + return (K) nodes[offset]; + } + + @Override + AbstractSetNode getCollectionValue(final int index) { + // TODO: improve on offset calculation (caching it, etc) + int offset = TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + index) + 1; + return (AbstractSetNode) nodes[offset]; + } + + @Override + CompactSetMultimapNode getNode(final int index) { + return (CompactSetMultimapNode) nodes[nodes.length - 1 - index]; + } + + // @Override + // boolean hasPayload() { + // return rawMap2() != 0; + // } + // + // @Override + // int payloadArity() { + // return java.lang.Integer.bitCount(rawMap2()); + // } + + @Override + int emptyArity() { + return arity(bitmap(), PATTERN_EMPTY); + } + + @Override + boolean hasPayload(EitherSingletonOrCollection.Type type) { + return payloadArity(type) != 0; + } + + @Override + int payloadArity(EitherSingletonOrCollection.Type type) { + // int[] arities = arities(bitmap()); + // return arities[PATTERN_NODE]; + + if (type == Type.SINGLETON) { + // return arities[PATTERN_DATA_SINGLETON]; + return arity(bitmap(), PATTERN_DATA_SINGLETON); + } else { + // return arities[PATTERN_DATA_COLLECTION]; + return arity(bitmap(), PATTERN_DATA_COLLECTION); + } + } + + @Override + boolean hasNodes() { + return nodeArity() != 0; + } + + @Override + int nodeArity() { + // int[] arities = arities(bitmap()); + // return arities[PATTERN_NODE]; + return arity(bitmap(), PATTERN_NODE); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = (int) (prime * result + (bitmap())); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedSetMultimapNode that = (BitmapIndexedSetMultimapNode) other; + if (bitmap() != that.bitmap()) { + return false; + } + if (!Arrays.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + + // switch (slotArity()) { + // case 0: + // return SIZE_EMPTY; + // case 1: + // return SIZE_MORE_THAN_ONE; // works for maps only: must be subnode; patternOfSingleton(); + // case 2: + // return arity(bitmap(), PATTERN_NODE) == 0 ? SIZE_ONE : SIZE_MORE_THAN_ONE; + // default: + // return SIZE_MORE_THAN_ONE; + // } + + // if (this.nodeArity() == 0) { + // switch (this.payloadArity()) { + // case 0: + // return SIZE_EMPTY; + // case 1: + // return SIZE_ONE; + // default: + // return SIZE_MORE_THAN_ONE; + // } + // } else { + // return SIZE_MORE_THAN_ONE; + // } + + // int[] arities = arities(bitmap()); + // + // int nodeArity = arities[PATTERN_NODE]; + // int emptyArity = arities[PATTERN_EMPTY]; + + final long bitmap = this.bitmap(); + + int nodeArity = arity(bitmap, PATTERN_NODE); + int emptyArity = arity(bitmap, PATTERN_EMPTY); + + // int aritySingleton = arity(bitmap, PATTERN_DATA_SINGLETON); + // int arityCollection = arity(bitmap, PATTERN_DATA_COLLECTION); + + if (nodeArity > 0) { + return SIZE_MORE_THAN_ONE; + } else { + switch (emptyArity) { + case 32: + return SIZE_EMPTY; + case 31: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } + + // if (this.nodeArity() == 0) { + // switch (arity(bitmap(), PATTERN_DATA_SINGLETON) + // + arity(bitmap(), PATTERN_DATA_COLLECTION)) { + // case 0: + // return SIZE_EMPTY; + // case 1: + // return SIZE_ONE; + // default: + // return SIZE_MORE_THAN_ONE; + // } + // } else { + // return SIZE_MORE_THAN_ONE; + // } + } + + @Override + CompactSetMultimapNode copyAndSetSingletonValue(final AtomicReference mutator, + final long doubledBitpos, final V val) { + + final int idx = TUPLE_LENGTH * dataIndex(doubledBitpos) + 1; + final CompactSetMultimapNode updatedNode = copyAndSetXxxValue(mutator, idx, val); + + return updatedNode; + } + + @Override + CompactSetMultimapNode copyAndSetCollectionValue(final AtomicReference mutator, + final long doubledBitpos, final AbstractSetNode valColl) { + + final int idx = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)) + 1; + final CompactSetMultimapNode updatedNode = copyAndSetXxxValue(mutator, idx, valColl); + + return updatedNode; + } + + private CompactSetMultimapNode copyAndSetXxxValue(final AtomicReference mutator, + final int idx, final Object newValue) { + final CompactSetMultimapNode updatedNode; + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = newValue; + updatedNode = this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = newValue; + + updatedNode = nodeOf(mutator, bitmap(), dst); + } + return updatedNode; + } + + @Override + CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final long doubledBitpos, final CompactSetMultimapNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(doubledBitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, bitmap(), dst); + } + } + + @Override + CompactSetMultimapNode copyAndInsertSingleton(final AtomicReference mutator, + final long doubledBitpos, final K key, final V val) { + final int idx = TUPLE_LENGTH * dataIndex(doubledBitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = val; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_DATA_SINGLETON); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndInsertCollection(final AtomicReference mutator, + final long doubledBitpos, final K key, final AbstractSetNode valColl) { + final int idx = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = valColl; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_DATA_COLLECTION); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + AtomicReference mutator, long doubledBitpos, K key, AbstractSetNode valColl) { + + final int idxOld = TUPLE_LENGTH * dataIndex(doubledBitpos); + final int idxNew = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) - 1 + collIndex(doubledBitpos)); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = key; + dst[idxNew + 1] = valColl; + System.arraycopy(src, idxNew + 2, dst, idxNew + 2, src.length - idxNew - 2); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_DATA_COLLECTION); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + AtomicReference mutator, long doubledBitpos, K key, V val) { + + // TODO: does not support src == dst yet for shifting + + final int idxOld = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + final int idxNew = TUPLE_LENGTH * dataIndex(doubledBitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' + assert idxNew <= idxOld; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = key; + dst[idxNew + 1] = val; + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 2, dst, idxOld + 2, src.length - idxOld - 2); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_DATA_SINGLETON); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(final AtomicReference mutator, + final long doubledBitpos) { + final int idx = TUPLE_LENGTH * dataIndex(doubledBitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_EMPTY); + return nodeOf(mutator, updatedBitmap, dst); + } + + // TODO: remove code duplication and merge with above + @Override + CompactSetMultimapNode copyAndRemoveSingleton(final AtomicReference mutator, + final long doubledBitpos, long updatedBitmap) { + final int idx = TUPLE_LENGTH * dataIndex(doubledBitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndRemoveCollection(final AtomicReference mutator, + final long doubledBitpos) { + final int idx = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_EMPTY); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToNode( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(doubledBitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(doubledBitpos); + + final Object[] dst = copyAndMigrateFromXxxToNode(idxOld, idxNew, node); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_NODE); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToNode(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + + final int idxOld = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(doubledBitpos); + + final Object[] dst = copyAndMigrateFromXxxToNode(idxOld, idxNew, node); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_NODE); + return nodeOf(mutator, updatedBitmap, dst); + } + + private Object[] copyAndMigrateFromXxxToNode(final int idxOld, final int idxNew, + final CompactSetMultimapNode node) { + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2 + 1]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 2, dst, idxNew + 1, src.length - idxNew - 2); + + return dst; + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(doubledBitpos); + final int idxNew = TUPLE_LENGTH * dataIndex(doubledBitpos); + + Object keyToInline = node.getSingletonKey(0); + Object valToInline = node.getSingletonValue(0); + + final Object[] dst = copyAndMigrateFromNodeToXxx(idxOld, idxNew, keyToInline, valToInline); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_DATA_SINGLETON); + return nodeOf(mutator, updatedBitmap, dst); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToCollection(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(doubledBitpos); + final int idxNew = + TUPLE_LENGTH * (arity(bitmap(), PATTERN_DATA_SINGLETON) + collIndex(doubledBitpos)); + + Object keyToInline = node.getCollectionKey(0); + Object valToInline = node.getCollectionValue(0); + + final Object[] dst = copyAndMigrateFromNodeToXxx(idxOld, idxNew, keyToInline, valToInline); + + long updatedBitmap = setBitPattern(bitmap(), doubledBitpos, PATTERN_DATA_COLLECTION); + return nodeOf(mutator, updatedBitmap, dst); + } + + private Object[] copyAndMigrateFromNodeToXxx(final int idxOld, final int idxNew, + Object keyToInline, Object valToInline) { + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 2]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = keyToInline; + dst[idxNew + 1] = valToInline; + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 2, src.length - idxOld - 1); + + return dst; + } + + @Override + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + final long bitmap) { + return nodeOf(mutator, bitmap, nodes); + } + + @Override + int patternOfSingleton() { + assert this.sizePredicate() == SIZE_ONE; + + long bitmap = this.bitmap(); + + final int doubledMask = Long.numberOfTrailingZeros(bitmap) / 2 * 2; + final int pattern = pattern(bitmap, doubledMask); + + return pattern; + } + + @Override + State stateOfSingleton() { + assert this.sizePredicate() == SIZE_ONE; + + long bitmap = this.bitmap(); + + final int doubledMask = Long.numberOfTrailingZeros(bitmap) / 2 * 2; + final int pattern = pattern(bitmap, doubledMask); + + return toState(pattern); + } + + @Deprecated + @Override + EitherSingletonOrCollection.Type typeOfSingleton() { + final int pattern = patternOfSingleton(); + + if (pattern == PATTERN_DATA_SINGLETON) { + return EitherSingletonOrCollection.Type.SINGLETON; + } else { + return EitherSingletonOrCollection.Type.COLLECTION; + } + } + + } + + private static abstract class AbstractHashCollisionNode + extends CompactSetMultimapNode { + +// // TODO: remove constructor and stored properties within CompactSetMultimapNode +// AbstractHashCollisionNode() { +// super(null, 0L); +// } + + static final > AbstractHashCollisionNode of( + final int hash, final K key0, final VS valColl0, final K key1, final VS valColl1) { + return new HashCollisionNode<>(hash, key0, valColl0, key1, valColl1); + } + + private static final RuntimeException UOE_BOILERPLATE = new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + private static final Supplier UOE_FACTORY = + () -> new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + @Override + CompactSetMultimapNode copyAndSetSingletonValue(AtomicReference mutator, + long doubledBitpos, V val) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndSetCollectionValue(AtomicReference mutator, + long doubledBitpos, AbstractSetNode valColl) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndSetNode(AtomicReference mutator, long doubledBitpos, + CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndInsertSingleton(AtomicReference mutator, + long doubledBitpos, K key, V val) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + AtomicReference mutator, long doubledBitpos, K key, AbstractSetNode valColl) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(AtomicReference mutator, + long doubledBitpos) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveCollection(AtomicReference mutator, + long doubledBitpos) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromSingletonToNode(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToNode(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToCollection(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + long bitmap) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndInsertCollection(AtomicReference mutator, + long doubledBitpos, K key, AbstractSetNode valColl) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(AtomicReference mutator, + long doubledBitpos, long updatedBitmap) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + AtomicReference mutator, long doubledBitpos, K key, V val) { + throw UOE_FACTORY.get(); + } + + @Override + long bitmap() { + throw UOE_FACTORY.get(); + } + + @Override + int emptyArity() { + throw UOE_FACTORY.get(); + } + + @Override + Type typeOfSingleton() { + throw UOE_FACTORY.get(); + } + + @Override + int patternOfSingleton() { + throw UOE_FACTORY.get(); + } + } + + private static final class HashCollisionNode extends AbstractHashCollisionNode { + + private final int hash; + private final List>> collisionContent; + + HashCollisionNode(final int hash, final K key0, + final io.usethesource.capsule.Set.Immutable valColl0, final K key1, + final io.usethesource.capsule.Set.Immutable valColl1) { + this(hash, Arrays.asList(entryOf(key0, valColl0), entryOf(key1, valColl1))); + } + + HashCollisionNode(final int hash, + final List>> collisionContent) { + this.hash = hash; + this.collisionContent = collisionContent; + } + + private static final RuntimeException UOE = new UnsupportedOperationException(); + + private static final Supplier UOE_NOT_YET_IMPLEMENTED_FACTORY = + () -> new UnsupportedOperationException("Not yet implemented @ HashCollisionNode."); + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + CompactSetMultimapNode getNode(int index) { + throw UOE; + } + + @Override + boolean hasPayload(EitherSingletonOrCollection.Type type) { + switch (type) { + case SINGLETON: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).findAny() + .isPresent(); + case COLLECTION: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).findAny() + .isPresent(); + } + throw new RuntimeException(); + } + + @Override + int payloadArity(EitherSingletonOrCollection.Type type) { + switch (type) { + case SINGLETON: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).count(); + case COLLECTION: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).count(); + } + throw new RuntimeException(); + } + + @Override + K getSingletonKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getKey(); + } + + @Override + V getSingletonValue(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getValue().stream().findAny().get(); + } + + @Override + K getCollectionKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getKey(); + } + + @Override + AbstractSetNode getCollectionValue(int index) { + io.usethesource.capsule.Set.Immutable result = collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getValue(); + + return setToNode(result); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return collisionContent.size() * 2; + } + + @Override + Object getSlot(int index) { + if (index % 2 == 0) { + return collisionContent.get(index / 2).getKey(); + } else { + return collisionContent.get(index / 2).getValue(); + } + } + + @Override + boolean containsKey(K key, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny() + .isPresent(); + } + + @Override + boolean containsTuple(K key, V val, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) + && entry.getValue().containsEquivalent(val, cmp.toComparator())) + .findAny().isPresent(); + } + + @Override + Optional> findByKey(K key, int keyHash, int shift, + EqualityComparator cmp) { + throw UOE_NOT_YET_IMPLEMENTED_FACTORY.get(); + } + + @Override + CompactSetMultimapNode inserted(AtomicReference mutator, K key, V val, + int keyHash, int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + if (values.containsEquivalent(val, cmp.toComparator())) { + // contains key and value + details.unchanged(); + return this; + + } else { + // contains key but not value + + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = + values.__insertEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + // TODO does not check that remainder is unmodified + assert updatedCollisionContent.size() == collisionContent.size(); + assert updatedCollisionContent.contains(optionalTuple.get()) == false; + // assert updatedCollisionContent.contains(entryOf(key, values.__insertEquivalent(val, + // cmp.toComparator()))); + assert updatedCollisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) + && entry.getValue().containsEquivalent(val, cmp.toComparator())) + .findAny().isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder() + .add(entryOf(key, setOf(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + assert updatedCollisionContent.size() == collisionContent.size() + 1; + assert updatedCollisionContent.containsAll(collisionContent); + // assert updatedCollisionContent.contains(entryOf(key, setOf(val))); + assert updatedCollisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey()) + && Objects.equals(setOf(val), entry.getValue())).findAny().isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode updated(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key -> replace val anyways + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = values + .__insertEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + if (values.size() == 1) { + details.updated(values.stream().findAny().get()); // unbox singleton + } else { + details.updated(setToNode(values)); + } + + return new HashCollisionNode(hash, updatedCollisionContent); + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder() + .add(entryOf(key, setOf(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode removed(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + if (values.containsEquivalent(val, cmp.toComparator())) { + // contains key and value -> remove mapping + + final List>> updatedCollisionContent; + + if (values.size() == 1) { + updatedCollisionContent = collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry != optionalTuple.get()) + .collect(Collectors.toList()); + } else { + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = + values.__removeEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + } + + details.updated(val); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + details.unchanged(); + return this; + } + + @Override + State stateOfSingleton() { + return null; + } + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueSingletonCursor; + protected int currentValueSingletonLength; + protected int currentValueCollectionCursor; + protected int currentValueCollectionLength; + protected AbstractSetMultimapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractSetMultimapNode[] nodes = new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapIterator(AbstractSetMultimapNode rootNode) { + int nodeArity = rootNode.nodeArity(); + if (nodeArity != 0) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = nodeArity; + } + + int emptyArity = rootNode.emptyArity(); + if (emptyArity + nodeArity < 32) { + currentValueNode = rootNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = rootNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = rootNode.payloadArity(COLLECTION); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractSetMultimapNode nextNode = + nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + int nodeArity = nextNode.nodeArity(); + if (nodeArity != 0) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nodeArity; + } + + // int emptyArity = nextNode.emptyArity(); + // if (emptyArity + nodeArity < 32) { + if (nextNode.hasPayload(SINGLETON) || nextNode.hasPayload(COLLECTION)) { + // if (payloadAritySingleton != 0 || payloadArityCollection != 0) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = nextNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = nextNode.payloadArity(Type.COLLECTION); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueSingletonCursor < currentValueSingletonLength + || currentValueCollectionCursor < currentValueCollectionLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetMultimapKeyIterator extends AbstractSetMultimapIterator + implements Iterator { + + SetMultimapKeyIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return currentValueNode.getSingletonKey(currentValueSingletonCursor++); + } else { + return currentValueNode.getCollectionKey(currentValueCollectionCursor++); + } + } + } + + } + + protected static class SetMultimapValueIterator extends AbstractSetMultimapIterator + implements Iterator> { + + SetMultimapValueIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public AbstractSetNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return setNodeOf(currentValueNode.getSingletonValue(currentValueSingletonCursor++)); + } else { + return currentValueNode.getCollectionValue(currentValueCollectionCursor++); + } + } + } + + } + + protected static class SetMultimapNativeTupleIterator + extends AbstractSetMultimapIterator implements Iterator> { + + SetMultimapNativeTupleIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + final K currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + final Object currentValue = + currentValueNode.getSingletonValue(currentValueSingletonCursor); + currentValueSingletonCursor++; + + return AbstractSpecialisedImmutableMap.entryOf(currentKey, currentValue); + } else { + final K currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + final Object currentValue = + currentValueNode.getCollectionValue(currentValueCollectionCursor); + currentValueCollectionCursor++; + + return AbstractSpecialisedImmutableMap.entryOf(currentKey, currentValue); + } + } + } + + } + + protected static class SetMultimapTupleIterator extends AbstractSetMultimapIterator + implements Iterator { + + final BiFunction tupleOf; + + K currentKey = null; + V currentValue = null; + Iterator currentSetIterator = Collections.emptyIterator(); + + SetMultimapTupleIterator(AbstractSetMultimapNode rootNode, + final BiFunction tupleOf) { + super(rootNode); + this.tupleOf = tupleOf; + } + + @Override + public boolean hasNext() { + if (currentSetIterator.hasNext()) { + return true; + } else { + if (super.hasNext()) { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + currentSetIterator = Collections + .singleton(currentValueNode.getSingletonValue(currentValueSingletonCursor)) + .iterator(); + currentValueSingletonCursor++; + } else { + currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + currentSetIterator = + currentValueNode.getCollectionValue(currentValueCollectionCursor).iterator(); + currentValueCollectionCursor++; + } + + return true; + } else { + return false; + } + } + } + + @Override + public T next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + currentValue = currentSetIterator.next(); + return tupleOf.apply(currentKey, currentValue); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieSetMultimap_BleedingEdgeNodeIterator + implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieSetMultimap_BleedingEdgeNodeIterator(AbstractSetMultimapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractSetMultimapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieSetMultimap_BleedingEdge + implements SetMultimap.Transient { + + private final EqualityComparator cmp; + + final private AtomicReference mutator; + private AbstractSetMultimapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieSetMultimap_BleedingEdge( + TrieSetMultimap_HHAMT_Interlinked trieSetMultimap_BleedingEdge) { + this.cmp = trieSetMultimap_BleedingEdge.cmp; + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieSetMultimap_BleedingEdge.rootNode; + this.hashCode = trieSetMultimap_BleedingEdge.hashCode; + this.cachedSize = trieSetMultimap_BleedingEdge.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.equals(iterator.next(), o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get().contains(val, val.hashCode(), 0); + } else { + return false; + } + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return setFromNode(result.get()); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public boolean __put(K key, io.usethesource.capsule.Set.Immutable valColl) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + // if (valColl.size() == 1) { + // throw new IllegalStateException(); + // } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = rootNode.updated(null, key, + setToNode(valColl), transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = valColl.hashCode(); + + rootNode = newRootNode; + // hashCode += 0; + // cachedSize += 0; + + // return new TrieSetMultimap_HHAMT(cmp, newRootNode, + // hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + + throw new IllegalStateException(); + // + // return true; + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + final int valHashNew = valColl.hashCode(); + + rootNode = newRootNode; + // hashCode += 0; + // cachedSize += 0; + + // return new TrieSetMultimap_HHAMT(cmp, newRootNode, + // hashCode + ((keyHash ^ valHashNew)) - sumOfReplacedHashes, + // cachedSize - details.getReplacedCollection().size() + 1); + + throw new IllegalStateException(); + // + // return true; + } + } + + int sumOfNewHashes = 0; + + // for (V newValue : valColl) { + // sumOfNewHashes += (keyHash ^ newValue.hashCode()); + // } + + rootNode = newRootNode; + hashCode += sumOfNewHashes; + cachedSize += valColl.size(); + + // final int valHash = valColl.hashCode(); + // return new TrieSetMultimap_HHAMT(cmp, newRootNode, hashCode + ((keyHash ^ + // valHash)), + // cachedSize + 1); + + return true; + } + + return false; + } + + @Override + public boolean __insert(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + /* + * TODO: Fix __put(K key, AbstractSetNode valColl) for batch insertion and re-enabled + * fast-fail check. + */ + // final int valHashNew = val.hashCode(); + rootNode = newRootNode; + // hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean union(final SetMultimap setMultimap) { + boolean modified = false; + + for (Map.Entry entry : setMultimap.entrySet()) { + modified |= this.__insert(entry.getKey(), entry.getValue()); + } + + return modified; + } + + @Override + public boolean __remove(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return false; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new TransientSetMultimapKeyIterator<>(this); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(AbstractSetNode::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + return new TransientSetMultimapTupleIterator<>(this, + AbstractSpecialisedImmutableMap::entryOf); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new TransientSetMultimapTupleIterator<>(this, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + public static class TransientSetMultimapKeyIterator extends SetMultimapKeyIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + K lastKey; + + public TransientSetMultimapKeyIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapValueIterator + extends SetMultimapValueIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapValueIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public AbstractSetNode next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapTupleIterator + extends SetMultimapTupleIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapTupleIterator( + final TransientTrieSetMultimap_BleedingEdge collection, + final BiFunction tupleOf) { + super(collection.rootNode, tupleOf); + this.collection = collection; + } + + @Override + public T next() { + return super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(currentKey, currentValue); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieSetMultimap_BleedingEdge.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieSetMultimap_BleedingEdge) { + TransientTrieSetMultimap_BleedingEdge that = + (TransientTrieSetMultimap_BleedingEdge) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + /* + * TODO: Fix __put(K key, AbstractSetNode valColl) for batch insertion and re-enabled + * fast-fail check. + */ + // if (this.hashCode != that.hashCode) { + // return false; + // } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + final AbstractSetNode valColl = (AbstractSetNode) entry.getValue(); + + if (!cmp.equals(result.get(), valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public SetMultimap.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieSetMultimap_HHAMT_Interlinked(cmp, rootNode, hashCode, cachedSize); + } + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specializations.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specializations.java new file mode 100644 index 0000000..3faf727 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specializations.java @@ -0,0 +1,124448 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.multimap; + +import java.util.concurrent.atomic.AtomicReference; + +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized.CompactSetMultimapNode; + +import static io.usethesource.capsule.util.DataLayoutHelper.addressSize; + +@SuppressWarnings({"unused", "rawtypes", "restriction"}) +public class TrieSetMultimap_HHAMT_Specializations { + + protected static class SetMultimap12To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + + protected SetMultimap12To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + } + } + + protected static class SetMultimap29To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + + protected SetMultimap29To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap6To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap6To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap2To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap2To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap27To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap27To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap2To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap2To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap1To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap1To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap1To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap1To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap5To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap5To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap6To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap6To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap20To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap20To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap4To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap4To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap3To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap3To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap1To61Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 61; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 60 * addressSize; + + static final long nodeBase = rareBase + 61 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + + protected SetMultimap1To61Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58, + final Object slot59, final Object slot60) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + } + } + + protected static class SetMultimap23To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap23To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap18To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + + protected SetMultimap18To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + } + } + + protected static class SetMultimap17To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap17To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap4To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap4To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap26To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap26To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap7To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap7To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap15To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap15To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap5To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap5To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap12To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap12To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap11To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap11To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap31To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 31; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 62 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final K key31; + private final V val31; + + protected SetMultimap31To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final K key31, final V val31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + } + } + + protected static class SetMultimap7To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap7To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap16To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap16To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap3To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap3To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap0To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap0To45Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap13To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap13To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap21To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap21To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap9To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap9To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap6To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap6To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap1To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap1To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap15To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap15To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap10To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + + protected SetMultimap10To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap5To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap5To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap3To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap3To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap3To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap26To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap26To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap7To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap7To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap11To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap11To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap8To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap8To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap8To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap8To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap1To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap1To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap0To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final Object slot0; + private final Object slot1; + + protected SetMultimap0To2Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap5To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap5To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap2To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap2To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap16To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap16To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap28To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + + protected SetMultimap28To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + } + } + + protected static class SetMultimap9To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap9To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap26To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap26To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap4To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap4To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap2To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap2To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap19To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap19To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap13To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap13To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap0To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap0To51Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap7To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap7To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap8To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + + protected SetMultimap8To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + } + } + + protected static class SetMultimap17To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap17To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap14To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + + protected SetMultimap14To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + } + } + + protected static class SetMultimap9To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap9To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap12To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap12To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap2To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap2To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap11To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap11To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap8To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap8To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap3To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap3To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap27To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap27To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap10To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap10To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap19To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap19To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap1To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap1To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap12To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap12To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap24To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + + protected SetMultimap24To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + } + } + + protected static class SetMultimap6To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap6To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap0To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap0To9Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap7To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap7To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap13To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap13To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap22To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + + protected SetMultimap22To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + } + } + + protected static class SetMultimap13To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap13To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap0To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap0To38Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap0To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap0To27Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap9To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap9To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap18To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap18To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap4To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap4To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap16To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap16To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap3To57Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 57; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected SetMultimap3To57Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class SetMultimap2To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap2To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap6To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap6To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap5To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap5To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap22To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap22To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap10To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap10To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap10To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap10To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap4To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + + protected SetMultimap4To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + } + } + + protected static class SetMultimap17To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap17To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap5To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap5To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap9To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap9To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap8To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap8To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap17To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap17To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap9To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap9To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap13To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap13To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap20To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap20To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap2To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap2To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap11To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap11To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap26To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap26To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap23To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap23To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap6To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap6To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap13To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap13To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap17To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap17To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap16To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap16To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap8To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap8To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap1To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap1To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap2To60Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 60; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 59 * addressSize; + + static final long nodeBase = rareBase + 60 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + + protected SetMultimap2To60Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57, final Object slot58, final Object slot59) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + } + } + + protected static class SetMultimap21To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap21To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap11To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap11To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap6To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap6To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap10To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap10To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap30To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final Object slot0; + private final Object slot1; + + protected SetMultimap30To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap7To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap7To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap3To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap3To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap3To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap3To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap15To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap15To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap4To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap4To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap28To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap28To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap0To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap0To20Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap15To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + + protected SetMultimap15To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + } + } + + protected static class SetMultimap14To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap14To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap5To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap5To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap17To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap17To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap14To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap14To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap25To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap25To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap1To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap1To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap4To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap4To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap22To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap22To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap2To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap2To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap9To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + + protected SetMultimap9To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap6To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap6To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap1To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap1To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap20To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap20To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap10To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap10To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap24To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap24To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap7To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap7To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap26To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap26To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap19To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap19To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap8To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap8To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap11To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap14To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap14To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap13To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap13To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap3To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap3To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap0To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap0To28Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap23To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap23To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap12To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap12To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap18To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap18To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap5To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap5To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap15To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap15To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap4To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap4To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap14To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap14To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap13To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap13To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap11To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap11To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap1To57Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 57; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected SetMultimap1To57Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class SetMultimap12To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap12To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap6To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap6To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap4To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap4To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap21To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + + protected SetMultimap21To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + } + } + + protected static class SetMultimap0To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap0To14Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap9To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap9To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap12To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap12To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap10To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap10To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap3To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap3To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap7To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap7To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap20To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap20To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap19To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap19To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap2To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap2To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap15To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap15To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap0To52Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap7To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap7To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap8To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap8To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap6To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + + protected SetMultimap6To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + } + } + + protected static class SetMultimap5To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap5To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap2To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap2To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap16To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + + protected SetMultimap16To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap4To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap4To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap1To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap1To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap21To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap21To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap18To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap18To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap4To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap4To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap11To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap11To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap13To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap13To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap16To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap16To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap26To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + + protected SetMultimap26To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + } + } + + protected static class SetMultimap2To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap2To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap12To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap12To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap13To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap13To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap7To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap7To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap10To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap10To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap1To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap1To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap8To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap8To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap5To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap5To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap8To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap8To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap0To58Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 58; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected SetMultimap0To58Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class SetMultimap18To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap18To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap25To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap25To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap0To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap0To13Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap12To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap12To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap17To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap17To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap3To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap21To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap21To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap6To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap6To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap0To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap0To40Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap0To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap0To55Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap3To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap3To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap17To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap17To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap28To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap28To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap16To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap16To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap7To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap7To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap9To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap9To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap14To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap14To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap11To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap11To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap15To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap15To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap1To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap1To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap14To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap14To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap28To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap28To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap5To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap5To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap10To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap10To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap4To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap4To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap11To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap11To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap1To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap1To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap0To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap0To31Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap5To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap5To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap12To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap12To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap23To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + + protected SetMultimap23To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap17To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap17To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap22To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap22To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap2To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap2To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap3To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap3To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap18To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap18To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap8To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap8To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap12To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap12To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap3To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap1To59Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 59; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 58 * addressSize; + + static final long nodeBase = rareBase + 59 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + + protected SetMultimap1To59Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + } + } + + protected static class SetMultimap7To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap7To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap11To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap11To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap7To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap7To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap6To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap6To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap5To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap5To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap14To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap14To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap9To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap9To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap20To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + + protected SetMultimap20To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap9To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap9To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap8To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap8To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap2To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + + protected SetMultimap2To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + } + } + + protected static class SetMultimap0To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap0To41Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap1To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap1To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap18To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap18To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap25To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap25To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap19To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap19To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap9To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap9To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap16To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap16To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap4To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap4To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap13To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap13To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap24To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap24To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap10To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap10To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap19To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + + protected SetMultimap19To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + } + } + + protected static class SetMultimap14To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap14To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap10To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap10To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap6To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap6To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap15To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap15To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap28To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap28To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap14To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap14To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap3To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap3To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap11To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap11To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap16To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap16To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap9To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap9To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap21To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap21To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap15To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap15To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap4To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + + protected SetMultimap4To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap8To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap8To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap4To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap4To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap5To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap5To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap12To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap12To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap6To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap6To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap2To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap2To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap1To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap1To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap11To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap13To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap13To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap16To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap16To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap20To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap20To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap5To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap5To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap3To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap3To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap1To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap1To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap29To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap29To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap6To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap6To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap17To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap17To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap7To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap7To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap8To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap8To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap14To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap14To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap18To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap18To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap9To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap9To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap0To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap0To50Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap23To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap23To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap20To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap20To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap10To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap10To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap9To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap9To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap0To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap0To3Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap9To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap9To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap3To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap8To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap8To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap0To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap0To37Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap2To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap2To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap6To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap6To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap15To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap15To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap21To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap21To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap30To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final Object slot0; + + protected SetMultimap30To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + } + } + + protected static class SetMultimap12To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap12To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap12To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap12To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap4To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap4To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap14To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap14To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap18To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap18To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap16To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap16To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap1To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap1To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap21To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap21To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap5To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap5To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap11To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap11To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap32To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 32; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 64 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final K key31; + private final V val31; + private final K key32; + private final V val32; + + protected SetMultimap32To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final K key31, final V val31, final K key32, final V val32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + this.key32 = key32; + this.val32 = val32; + } + } + + protected static class SetMultimap6To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap6To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap10To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap10To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap13To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap13To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap19To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap19To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap23To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap23To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap12To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap12To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap17To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap17To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap18To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap18To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap2To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap2To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap7To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap7To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap17To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap17To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap23To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap23To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap19To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap19To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap1To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap1To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap1To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap1To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap23To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap23To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap18To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + + protected SetMultimap18To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap11To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap11To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap20To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap20To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + + protected SetMultimap3To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + } + } + + protected static class SetMultimap11To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + + protected SetMultimap11To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + } + } + + protected static class SetMultimap2To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap2To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap2To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap2To55Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap4To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap4To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap7To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap7To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap0To48Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap25To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + + protected SetMultimap25To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + } + } + + protected static class SetMultimap8To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap8To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap15To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap15To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap5To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap5To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap2To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap2To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap17To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + + protected SetMultimap17To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + } + } + + protected static class SetMultimap2To58Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 58; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected SetMultimap2To58Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class SetMultimap8To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap8To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap6To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap6To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap7To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap7To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap5To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap5To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap13To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap13To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap3To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap3To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap15To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap15To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap12To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + + protected SetMultimap12To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap9To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap9To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap3To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap3To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap29To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + + protected SetMultimap29To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + } + } + + protected static class SetMultimap16To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap16To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap20To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap20To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap6To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap6To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap3To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap3To56Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap9To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap9To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap4To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap4To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap5To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap5To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap14To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + + protected SetMultimap14To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap15To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap15To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap22To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap22To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap28To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + + protected SetMultimap28To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap1To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap1To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap7To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap7To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap0To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap0To39Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap5To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap5To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap30To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap30To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap8To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap8To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap5To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap5To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final Object slot0; + + protected SetMultimap0To1Node(final AtomicReference mutator, final long bitmap, + final Object slot0) { + super(mutator, bitmap); + this.slot0 = slot0; + } + } + + protected static class SetMultimap2To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap2To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap19To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap19To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap10To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap10To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap23To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap23To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap2To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap2To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap13To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap13To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap6To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap6To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap1To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap1To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap16To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap16To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap19To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap19To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap7To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap7To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap9To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap9To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap10To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + + protected SetMultimap10To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + } + } + + protected static class SetMultimap3To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap3To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap8To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap8To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap21To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap21To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap1To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap1To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap20To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap20To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap4To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap4To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap4To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap4To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap0To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap0To5Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap6To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap6To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap4To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap4To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap4To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap4To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap3To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap3To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap0To8Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap9To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap9To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap5To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap5To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap22To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap22To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap1To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap1To56Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap13To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap13To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap2To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap14To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap14To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap10To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap10To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap7To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap7To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap21To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap21To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap8To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap8To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap8To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap8To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap3To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap3To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap11To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap11To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap15To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap15To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap19To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap19To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap1To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap1To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap11To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap11To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap12To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap12To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap10To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap10To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap7To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + + protected SetMultimap7To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + } + } + + protected static class SetMultimap6To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap6To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap6To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap6To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap17To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap17To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap9To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap9To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap3To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap3To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap24To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap24To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap26To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + + protected SetMultimap26To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap7To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap7To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap5To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap5To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap5To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap5To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap1To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + + protected SetMultimap1To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + } + } + + protected static class SetMultimap17To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap17To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap29To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap29To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap14To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap14To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap2To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + + protected SetMultimap2To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap19To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap19To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap11To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap11To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap1To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap1To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap6To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap6To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap1To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap1To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap0To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap0To7Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap12To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap12To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap23To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + + protected SetMultimap23To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + } + } + + protected static class SetMultimap8To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap8To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap18To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap18To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap0To62Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 62; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 61 * addressSize; + + static final long nodeBase = rareBase + 62 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + + protected SetMultimap0To62Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59, + final Object slot60, final Object slot61) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + } + } + + protected static class SetMultimap21To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap21To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap2To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap2To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap10To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap10To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap12To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap12To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap4To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap4To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap16To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap16To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap5To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + + protected SetMultimap5To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + } + } + + protected static class SetMultimap0To64Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 64; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 63 * addressSize; + + static final long nodeBase = rareBase + 64 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + private final Object slot62; + private final Object slot63; + + protected SetMultimap0To64Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59, + final Object slot60, final Object slot61, final Object slot62, final Object slot63) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + this.slot62 = slot62; + this.slot63 = slot63; + } + } + + protected static class SetMultimap15To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap15To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap0To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap0To33Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap8To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap8To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap10To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap10To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap7To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap7To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap13To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap13To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap20To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + + protected SetMultimap20To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + } + } + + protected static class SetMultimap3To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap3To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap13To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap13To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap3To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap3To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap8To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap8To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap6To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap6To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap15To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap15To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap27To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + + protected SetMultimap27To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + } + } + + protected static class SetMultimap7To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap7To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap7To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap7To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap14To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap14To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap4To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap4To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap2To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap2To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap18To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap18To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap22To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap22To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap3To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap10To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap10To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap9To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap9To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap11To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap11To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap5To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap5To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap0To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap0To10Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap15To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap15To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap22To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap22To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap2To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap2To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap2To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap2To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap17To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap17To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap9To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + + protected SetMultimap9To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + } + } + + protected static class SetMultimap10To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap10To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap0To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap0To35Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap19To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap19To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap19To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap19To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap12To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap12To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap4To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap4To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap1To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap1To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap24To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap24To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap3To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap17To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap17To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap25To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap25To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap13To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + + protected SetMultimap13To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + } + } + + protected static class SetMultimap22To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap22To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap16To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + + protected SetMultimap16To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + } + } + + protected static class SetMultimap6To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + + protected SetMultimap6To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap24To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap24To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap19To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap19To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap18To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap18To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap0To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap0To16Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap20To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap20To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap4To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap4To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap15To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap15To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap7To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap7To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap23To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap23To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap10To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap10To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap0To60Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 60; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 59 * addressSize; + + static final long nodeBase = rareBase + 60 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + + protected SetMultimap0To60Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + } + } + + protected static class SetMultimap14To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap14To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap13To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap13To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap5To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap5To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap3To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap3To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap2To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap2To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap1To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap1To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap8To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap8To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap11To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap11To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap15To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap15To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap6To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap6To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap1To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap1To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap4To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap4To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap4To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap4To55Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap12To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap12To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap26To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap26To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap5To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap5To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap30To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + + protected SetMultimap30To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + } + } + + protected static class SetMultimap0To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap0To36Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap7To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap7To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap13To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap13To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap12To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap12To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap1To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap1To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap6To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap6To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap4To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap4To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap7To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap7To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap27To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap27To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap3To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap1To60Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 60; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 59 * addressSize; + + static final long nodeBase = rareBase + 60 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + + protected SetMultimap1To60Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58, + final Object slot59) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + } + } + + protected static class SetMultimap8To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap8To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap6To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap6To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap16To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap16To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap0To25Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap18To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap18To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap5To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap5To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap19To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap19To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap15To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + + protected SetMultimap15To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap12To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap12To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap18To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap18To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap9To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap9To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap14To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap14To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap4To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap4To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap10To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap10To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap27To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap27To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap9To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap9To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap10To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap10To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap2To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap2To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap13To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap13To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap4To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap4To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap3To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap3To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap11To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap11To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap21To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap21To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap1To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap1To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap12To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap12To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap9To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap9To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap3To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap3To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap23To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap23To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap27To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap27To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap10To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap10To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap6To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap6To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap9To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap9To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap4To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap4To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap8To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap8To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap8To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap8To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap18To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap18To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap14To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap14To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap5To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap5To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap20To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap20To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap0To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap0To22Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap2To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap25To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap25To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap14To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap14To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap11To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap11To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap7To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap7To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap17To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap17To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap22To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + + protected SetMultimap22To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap13To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap13To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap16To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap16To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap13To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap13To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap1To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap1To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap6To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap6To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap26To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap26To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap8To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap8To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap24To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + + protected SetMultimap24To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap5To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap5To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap10To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap10To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap5To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap5To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap14To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap14To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap27To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap27To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap6To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap6To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap26To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap26To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap5To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap5To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap0To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap0To47Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap4To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap4To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap2To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap2To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap0To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + protected SetMultimap0To0Node(final AtomicReference mutator, final long bitmap) { + super(mutator, bitmap); + + } + } + + protected static class SetMultimap3To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap3To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap13To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap13To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap1To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap1To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap7To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap7To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap10To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + + protected SetMultimap10To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + } + } + + protected static class SetMultimap7To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap7To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap23To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap23To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap12To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap12To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap2To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap2To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap18To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap18To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap4To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap4To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap0To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap0To18Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap1To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap1To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap16To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap16To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap20To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap20To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap1To62Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 62; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 61 * addressSize; + + static final long nodeBase = rareBase + 62 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + + protected SetMultimap1To62Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58, + final Object slot59, final Object slot60, final Object slot61) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + } + } + + protected static class SetMultimap8To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + + protected SetMultimap8To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap24To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap24To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap15To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap15To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap22To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap22To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap9To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap9To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap21To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap21To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap11To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + + protected SetMultimap11To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + } + } + + protected static class SetMultimap15To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap15To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap29To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + + protected SetMultimap29To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + } + } + + protected static class SetMultimap7To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap7To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap2To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap2To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap2To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap2To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap5To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap5To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap3To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap11To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap11To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap0To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap0To49Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap13To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap13To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap3To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + + protected SetMultimap3To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + } + } + + protected static class SetMultimap19To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap19To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap0To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap0To56Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap1To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap1To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap17To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + + protected SetMultimap17To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + } + } + + protected static class SetMultimap14To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap14To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap31To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 31; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 62 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final K key31; + private final V val31; + private final Object slot0; + private final Object slot1; + + protected SetMultimap31To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final K key31, final V val31, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap13To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap13To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap4To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap4To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap25To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + + protected SetMultimap25To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + } + } + + protected static class SetMultimap9To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap9To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap8To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap8To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap15To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap15To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap22To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap22To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap1To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap1To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap7To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap7To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap18To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap18To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap26To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap26To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap12To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap12To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap16To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap16To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap6To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap6To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap5To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap5To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap11To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap11To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap1To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap1To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap0To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap0To42Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap13To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap13To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap10To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap10To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap2To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap2To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap23To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap23To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap13To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap13To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap12To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap12To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap3To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap3To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap9To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap9To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap20To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + + protected SetMultimap20To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + } + } + + protected static class SetMultimap5To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap5To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap18To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap18To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap12To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap12To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap8To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap8To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap28To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap28To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap3To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap11To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap11To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap14To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap14To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap7To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap7To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap0To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap0To15Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap16To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap16To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap8To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap8To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap20To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap20To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap5To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + + protected SetMultimap5To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + } + } + + protected static class SetMultimap6To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap6To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap21To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap21To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap2To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap2To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap1To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + + protected SetMultimap1To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + } + } + + protected static class SetMultimap17To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap17To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap15To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap15To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap19To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + + protected SetMultimap19To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap25To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap25To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap17To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap17To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap4To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap4To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap0To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap0To53Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap10To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap10To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap2To59Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 59; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 58 * addressSize; + + static final long nodeBase = rareBase + 59 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + + protected SetMultimap2To59Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57, final Object slot58) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + } + } + + protected static class SetMultimap25To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap25To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap14To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap14To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap23To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + + protected SetMultimap23To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + } + } + + protected static class SetMultimap11To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap11To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap3To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap3To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap7To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + + protected SetMultimap7To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + } + } + + protected static class SetMultimap4To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap4To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap8To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap8To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap0To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap0To43Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap24To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap24To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap7To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap7To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap14To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap14To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap27To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap27To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap12To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap12To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap2To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap2To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap16To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap16To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap2To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap18To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap18To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap8To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap8To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap6To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap6To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap9To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap9To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap10To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap10To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap10To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap10To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap9To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap9To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap1To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap1To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap21To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap21To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap11To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap11To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap6To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap6To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap17To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap17To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap22To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap22To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap5To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap5To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap12To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap12To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap25To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap25To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap18To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap18To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap15To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap15To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap3To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap3To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap14To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap14To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap0To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap0To29Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap1To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap1To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap6To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap6To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap12To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap12To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap14To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap14To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap8To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap8To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap1To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap1To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap7To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap7To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap21To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + + protected SetMultimap21To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap4To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap4To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap4To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap4To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap11To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap11To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap5To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap5To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap6To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap6To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap2To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap2To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap22To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap22To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap10To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap10To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap25To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap25To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap3To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap3To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap17To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap17To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap11To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap11To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap24To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap24To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap28To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap28To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap15To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap15To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap16To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + + protected SetMultimap16To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + } + } + + protected static class SetMultimap5To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap5To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap13To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + + protected SetMultimap13To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + } + } + + protected static class SetMultimap2To57Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 57; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected SetMultimap2To57Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class SetMultimap3To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap3To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap16To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap16To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap19To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap19To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap0To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap0To30Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap15To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap15To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap0To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap0To54Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap1To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap1To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap4To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap4To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap5To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap5To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap7To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap7To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap17To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap17To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap8To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap8To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap18To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap18To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap12To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap12To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap6To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap6To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap27To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + + protected SetMultimap27To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + } + } + + protected static class SetMultimap2To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap2To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap4To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap4To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap3To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap3To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap10To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap10To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap2To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap2To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap0To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap0To12Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap6To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap6To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap9To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + + protected SetMultimap9To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + } + } + + protected static class SetMultimap20To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap20To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap11To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap11To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap7To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap7To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap19To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap19To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap9To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap9To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap14To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap14To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap6To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap6To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap7To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap7To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap2To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap2To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap8To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap8To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap23To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap23To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap5To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap5To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap5To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap5To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap20To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap20To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap1To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap1To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap0To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap0To46Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap7To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap7To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap28To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + + protected SetMultimap28To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + } + } + + protected static class SetMultimap19To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap19To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap23To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap23To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap2To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap2To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap8To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + + protected SetMultimap8To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + } + } + + protected static class SetMultimap15To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap15To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap14To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + + protected SetMultimap14To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + } + } + + protected static class SetMultimap20To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap20To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap10To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap10To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap13To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap13To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap9To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap9To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap14To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap14To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap0To59Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 59; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 58 * addressSize; + + static final long nodeBase = rareBase + 59 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + + protected SetMultimap0To59Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + } + } + + protected static class SetMultimap21To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap21To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap4To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap4To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap2To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap1To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap1To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap16To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap16To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap3To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap3To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap0To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap0To23Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap23To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap23To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap7To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap7To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap19To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap19To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap3To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap3To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap24To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap24To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap13To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap13To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap2To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap2To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap10To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap10To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap9To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap9To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap20To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap20To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap18To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + + protected SetMultimap18To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + } + } + + protected static class SetMultimap7To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap7To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap8To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap8To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap25To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + + protected SetMultimap25To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap19To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap19To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap22To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap22To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap17To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + + protected SetMultimap17To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap31To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 31; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 62 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final K key31; + private final V val31; + private final Object slot0; + + protected SetMultimap31To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final K key31, final V val31, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + this.slot0 = slot0; + } + } + + protected static class SetMultimap0To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap0To44Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap16To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap16To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap6To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap6To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap0To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap0To24Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap5To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap5To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap2To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap2To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap11To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + + protected SetMultimap11To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap21To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap21To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap1To58Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 58; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected SetMultimap1To58Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class SetMultimap18To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap18To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap3To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + + protected SetMultimap3To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap12To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap12To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap1To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap1To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap4To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap4To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap5To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap5To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap10To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap10To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap4To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap4To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap12To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + + protected SetMultimap12To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + } + } + + protected static class SetMultimap1To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap1To55Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap1To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap1To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap1To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap1To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap5To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap5To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap0To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap0To21Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap5To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap5To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap21To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap21To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap20To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap20To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap12To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap12To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap0To57Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 57; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected SetMultimap0To57Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class SetMultimap23To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap23To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap8To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap8To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap6To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap6To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap26To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap26To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap11To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap3To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap3To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap8To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap8To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap15To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + + protected SetMultimap15To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + } + } + + protected static class SetMultimap11To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap11To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap11To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap11To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap4To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap4To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap3To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap3To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap3To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap3To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap9To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap9To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap1To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap1To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap25To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap25To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap9To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap9To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap16To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap16To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap17To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap17To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap18To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap18To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap2To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap13To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap13To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap17To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap17To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap4To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap4To56Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap14To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap14To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap10To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap10To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap14To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap14To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap19To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap19To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap7To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap7To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap16To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap16To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap6To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap6To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap1To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap1To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap4To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap4To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap4To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap4To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap0To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap0To19Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap21To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap21To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap9To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap9To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap16To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap16To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap2To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap2To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap0To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap0To26Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap14To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap14To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap19To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap19To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap9To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap9To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap3To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap22To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + + protected SetMultimap22To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + } + } + + protected static class SetMultimap6To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap6To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap12To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap12To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap4To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + + protected SetMultimap4To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + } + } + + protected static class SetMultimap12To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap12To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap5To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap5To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap10To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap10To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap6To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap6To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap21To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap21To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap18To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap18To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap24To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + + protected SetMultimap24To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + } + } + + protected static class SetMultimap17To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap17To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap13To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap13To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap11To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap11To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap7To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap7To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap2To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap2To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap10To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap10To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap22To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap22To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap10To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap10To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap6To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + + protected SetMultimap6To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + } + } + + protected static class SetMultimap2To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap2To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap21To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + + protected SetMultimap21To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + } + } + + protected static class SetMultimap20To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap20To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap0To63Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 63; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 62 * addressSize; + + static final long nodeBase = rareBase + 63 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + private final Object slot62; + + protected SetMultimap0To63Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59, + final Object slot60, final Object slot61, final Object slot62) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + this.slot62 = slot62; + } + } + + protected static class SetMultimap18To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap18To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap11To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap12To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap12To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap8To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap8To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap24To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap24To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap17To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap17To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap4To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap4To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap19To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap19To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap15To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap15To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap9To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap9To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap4To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap4To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap14To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap14To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap9To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap9To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap5To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap5To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap13To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + + protected SetMultimap13To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap30To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap30To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap7To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap7To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap7To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap7To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap24To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap24To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap6To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap6To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap1To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap1To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap2To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap2To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap22To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap22To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap6To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap6To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap16To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap16To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap7To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap7To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap15To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap15To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap3To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap3To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap0To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap0To6Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap16To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap16To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap24To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap24To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap1To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap1To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap20To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap20To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap8To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap8To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap4To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap4To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap3To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap3To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap12To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap12To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap22To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap22To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap17To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap17To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap15To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap15To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap25To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap25To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap2To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap2To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap4To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap4To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap0To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap0To32Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap29To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap29To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap6To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap6To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap27To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + + protected SetMultimap27To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap8To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap8To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap5To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap5To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap14To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap14To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap15To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap15To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap3To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap3To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap10To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap10To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap5To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap5To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap5To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap5To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap7To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap7To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap9To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap9To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap4To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap4To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap9To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap9To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap11To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap11To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap1To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap1To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap1To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap1To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap9To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap9To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap16To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap16To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap3To58Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 58; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected SetMultimap3To58Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class SetMultimap0To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap0To17Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap4To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap4To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap11To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap21To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap21To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap10To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap10To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap24To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap24To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap25To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap25To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap5To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap5To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap12To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap12To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap2To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap2To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap27To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap27To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap13To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap13To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap5To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + + protected SetMultimap5To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap11To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap11To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap10To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap10To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap20To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap20To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap8To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap8To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap19To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + + protected SetMultimap19To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + } + } + + protected static class SetMultimap1To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + + protected SetMultimap1To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap3To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap3To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap3To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap3To55Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap3To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap3To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap2To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + + protected SetMultimap2To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + } + } + + protected static class SetMultimap14To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap14To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap0To4Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap8To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap8To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap7To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap7To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap17To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap17To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap9To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap9To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap1To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap1To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap6To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap6To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap15To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap15To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap4To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap4To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap6To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap6To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap2To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap2To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap22To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap22To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap13To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap13To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap9To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap9To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap16To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap16To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap8To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap8To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap0To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap0To11Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap1To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap1To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap11To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap11To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap5To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap5To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap18To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap18To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap3To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap3To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap10To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap10To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap10To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap10To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap26To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + + protected SetMultimap26To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + } + } + + protected static class SetMultimap6To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap6To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap24To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap24To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap7To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + + protected SetMultimap7To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap22To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap22To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap16To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap16To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap15To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap15To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap4To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap4To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap29To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap29To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap14To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap14To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap0To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap0To34Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap8To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap8To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap3To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap3To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap11To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap11To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap12To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap12To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap2To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap2To56Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap0To61Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 61; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 60 * addressSize; + + static final long nodeBase = rareBase + 61 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + + protected SetMultimap0To61Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59, + final Object slot60) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + } + } + + protected static class SetMultimap2To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap2To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap20To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap20To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap13To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap13To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap13To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap13To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specializations_Interlinked.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specializations_Interlinked.java new file mode 100644 index 0000000..ecbf778 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specializations_Interlinked.java @@ -0,0 +1,124448 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.multimap; + +import java.util.concurrent.atomic.AtomicReference; + +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized_Interlinked.CompactSetMultimapNode; + +import static io.usethesource.capsule.util.DataLayoutHelper.addressSize; + +@SuppressWarnings({"rawtypes", "restriction"}) +public class TrieSetMultimap_HHAMT_Specializations_Interlinked { + + protected static class SetMultimap12To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + + protected SetMultimap12To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + } + } + + protected static class SetMultimap29To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + + protected SetMultimap29To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap6To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap6To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap2To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap2To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap27To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap27To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap2To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap2To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap1To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap1To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap1To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap1To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap5To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap5To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap6To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap6To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap20To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap20To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap4To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap4To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap3To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap3To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap1To61Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 61; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 60 * addressSize; + + static final long nodeBase = rareBase + 61 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + + protected SetMultimap1To61Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58, + final Object slot59, final Object slot60) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + } + } + + protected static class SetMultimap23To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap23To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap18To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + + protected SetMultimap18To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + } + } + + protected static class SetMultimap17To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap17To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap4To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap4To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap26To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap26To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap7To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap7To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap15To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap15To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap5To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap5To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap12To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap12To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap11To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap11To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap31To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 31; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 62 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final K key31; + private final V val31; + + protected SetMultimap31To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final K key31, final V val31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + } + } + + protected static class SetMultimap7To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap7To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap16To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap16To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap3To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap3To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap0To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap0To45Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap13To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap13To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap21To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap21To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap9To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap9To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap6To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap6To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap1To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap1To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap15To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap15To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap10To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + + protected SetMultimap10To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap5To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap5To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap3To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap3To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap3To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap26To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap26To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap7To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap7To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap11To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap11To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap8To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap8To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap8To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap8To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap1To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap1To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap0To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final Object slot0; + private final Object slot1; + + protected SetMultimap0To2Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap5To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap5To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap2To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap2To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap16To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap16To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap28To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + + protected SetMultimap28To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + } + } + + protected static class SetMultimap9To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap9To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap26To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap26To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap4To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap4To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap2To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap2To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap19To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap19To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap13To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap13To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap0To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap0To51Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap7To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap7To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap8To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + + protected SetMultimap8To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + } + } + + protected static class SetMultimap17To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap17To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap14To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + + protected SetMultimap14To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + } + } + + protected static class SetMultimap9To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap9To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap12To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap12To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap2To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap2To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap11To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap11To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap8To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap8To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap3To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap3To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap27To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap27To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap10To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap10To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap19To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap19To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap1To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap1To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap12To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap12To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap24To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + + protected SetMultimap24To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + } + } + + protected static class SetMultimap6To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap6To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap0To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap0To9Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap7To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap7To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap13To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap13To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap22To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + + protected SetMultimap22To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + } + } + + protected static class SetMultimap13To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap13To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap0To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap0To38Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap0To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap0To27Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap9To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap9To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap18To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap18To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap4To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap4To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap16To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap16To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap3To57Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 57; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected SetMultimap3To57Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class SetMultimap2To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap2To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap6To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap6To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap5To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap5To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap22To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap22To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap10To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap10To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap10To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap10To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap4To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + + protected SetMultimap4To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + } + } + + protected static class SetMultimap17To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap17To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap5To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap5To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap9To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap9To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap8To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap8To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap17To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap17To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap9To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap9To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap13To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap13To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap20To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap20To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap2To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap2To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap11To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap11To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap26To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap26To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap23To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap23To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap6To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap6To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap13To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap13To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap17To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap17To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap16To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap16To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap8To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap8To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap1To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap1To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap2To60Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 60; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 59 * addressSize; + + static final long nodeBase = rareBase + 60 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + + protected SetMultimap2To60Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57, final Object slot58, final Object slot59) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + } + } + + protected static class SetMultimap21To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap21To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap11To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap11To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap6To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap6To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap10To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap10To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap30To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final Object slot0; + private final Object slot1; + + protected SetMultimap30To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap7To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap7To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap3To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap3To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap3To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap3To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap15To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap15To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap4To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap4To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap28To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap28To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap0To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap0To20Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap15To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + + protected SetMultimap15To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + } + } + + protected static class SetMultimap14To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap14To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap5To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap5To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap17To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap17To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap14To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap14To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap25To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap25To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap1To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap1To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap4To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap4To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap22To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap22To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap2To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap2To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap9To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + + protected SetMultimap9To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap6To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap6To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap1To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap1To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap20To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap20To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap10To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap10To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap24To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap24To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap7To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap7To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap26To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap26To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap19To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap19To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap8To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap8To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap11To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap14To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap14To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap13To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap13To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap3To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap3To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap0To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap0To28Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap23To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap23To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap12To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap12To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap18To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap18To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap5To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap5To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap15To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap15To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap4To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap4To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap14To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap14To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap13To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap13To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap11To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap11To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap1To57Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 57; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected SetMultimap1To57Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class SetMultimap12To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap12To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap6To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap6To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap4To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap4To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap21To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + + protected SetMultimap21To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + } + } + + protected static class SetMultimap0To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap0To14Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap9To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap9To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap12To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap12To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap10To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap10To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap3To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap3To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap7To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap7To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap20To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap20To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap19To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap19To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap2To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap2To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap15To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap15To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap0To52Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap7To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap7To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap8To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap8To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap6To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + + protected SetMultimap6To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + } + } + + protected static class SetMultimap5To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap5To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap2To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap2To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap16To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + + protected SetMultimap16To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap4To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap4To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap1To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap1To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap21To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap21To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap18To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap18To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap4To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap4To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap11To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap11To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap13To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap13To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap16To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap16To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap26To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + + protected SetMultimap26To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + } + } + + protected static class SetMultimap2To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap2To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap12To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap12To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap13To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap13To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap7To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap7To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap10To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap10To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap1To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap1To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap8To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap8To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap5To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap5To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap8To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap8To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap0To58Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 58; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected SetMultimap0To58Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class SetMultimap18To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap18To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap25To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap25To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap0To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap0To13Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap12To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap12To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap17To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap17To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap3To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap21To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap21To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap6To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap6To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap0To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap0To40Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap0To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap0To55Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap3To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap3To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap17To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap17To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap28To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap28To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap16To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap16To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap7To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap7To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap9To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap9To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap14To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap14To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap11To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap11To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap15To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap15To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap1To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap1To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap14To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap14To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap28To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap28To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap5To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap5To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap10To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap10To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap4To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap4To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap11To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap11To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap1To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap1To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap0To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap0To31Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap5To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap5To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap12To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap12To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap23To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + + protected SetMultimap23To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap17To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap17To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap22To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap22To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap2To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap2To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap3To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap3To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap18To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap18To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap8To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap8To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap12To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap12To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap3To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap1To59Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 59; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 58 * addressSize; + + static final long nodeBase = rareBase + 59 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + + protected SetMultimap1To59Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + } + } + + protected static class SetMultimap7To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap7To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap11To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap11To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap7To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap7To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap6To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap6To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap5To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap5To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap14To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap14To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap9To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap9To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap20To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + + protected SetMultimap20To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap9To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap9To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap8To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap8To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap2To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + + protected SetMultimap2To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + } + } + + protected static class SetMultimap0To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap0To41Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap1To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap1To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap18To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap18To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap25To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap25To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap19To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap19To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap9To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap9To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap16To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap16To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap4To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap4To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap13To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap13To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap24To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap24To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap10To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap10To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap19To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + + protected SetMultimap19To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + } + } + + protected static class SetMultimap14To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap14To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap10To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap10To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap6To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap6To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap15To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap15To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap28To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap28To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap14To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap14To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap3To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap3To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap11To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap11To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap16To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap16To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap9To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap9To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap21To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap21To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap15To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap15To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap4To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + + protected SetMultimap4To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap8To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap8To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap4To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap4To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap5To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap5To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap12To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap12To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap6To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap6To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap2To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap2To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap1To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap1To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap11To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap13To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap13To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap16To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap16To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap20To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap20To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap5To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap5To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap3To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap3To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap1To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap1To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap29To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap29To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap6To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap6To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap17To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap17To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap7To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap7To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap8To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap8To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap14To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap14To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap18To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap18To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap9To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap9To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap0To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap0To50Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap23To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap23To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap20To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap20To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap10To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap10To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap9To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap9To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap0To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap0To3Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap9To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap9To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap3To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap8To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap8To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap0To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap0To37Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap2To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap2To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap6To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap6To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap15To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap15To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap21To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap21To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap30To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final Object slot0; + + protected SetMultimap30To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + } + } + + protected static class SetMultimap12To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap12To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap12To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap12To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap4To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap4To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap14To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap14To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap18To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap18To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap16To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap16To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap1To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap1To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap21To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap21To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap5To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap5To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap11To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap11To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap32To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 32; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 64 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final K key31; + private final V val31; + private final K key32; + private final V val32; + + protected SetMultimap32To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final K key31, final V val31, final K key32, final V val32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + this.key32 = key32; + this.val32 = val32; + } + } + + protected static class SetMultimap6To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap6To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap10To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap10To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap13To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap13To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap19To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap19To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap23To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap23To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap12To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap12To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap17To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap17To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap18To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap18To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap2To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap2To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap7To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap7To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap17To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap17To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap23To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap23To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap19To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap19To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap1To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap1To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap1To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap1To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap23To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap23To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap18To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + + protected SetMultimap18To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap11To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap11To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap20To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap20To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + + protected SetMultimap3To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + } + } + + protected static class SetMultimap11To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + + protected SetMultimap11To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + } + } + + protected static class SetMultimap2To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap2To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap2To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap2To55Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap4To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap4To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap7To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap7To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap0To48Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap25To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + + protected SetMultimap25To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + } + } + + protected static class SetMultimap8To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap8To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap15To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap15To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap5To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap5To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap2To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap2To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap17To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + + protected SetMultimap17To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + } + } + + protected static class SetMultimap2To58Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 58; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected SetMultimap2To58Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class SetMultimap8To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap8To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap6To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap6To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap7To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap7To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap5To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap5To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap13To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap13To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap3To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap3To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap15To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap15To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap12To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + + protected SetMultimap12To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap9To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap9To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap3To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap3To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap29To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + + protected SetMultimap29To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + } + } + + protected static class SetMultimap16To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap16To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap20To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap20To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap6To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap6To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap3To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap3To56Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap9To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap9To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap4To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap4To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap5To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap5To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap14To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + + protected SetMultimap14To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap15To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap15To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap22To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap22To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap28To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + + protected SetMultimap28To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap1To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap1To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap7To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap7To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap0To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap0To39Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap5To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap5To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap30To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap30To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap8To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap8To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap5To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap5To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final Object slot0; + + protected SetMultimap0To1Node(final AtomicReference mutator, final long bitmap, + final Object slot0) { + super(mutator, bitmap); + this.slot0 = slot0; + } + } + + protected static class SetMultimap2To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap2To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap19To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap19To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap10To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap10To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap23To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap23To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap2To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap2To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap13To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap13To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap6To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap6To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap1To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap1To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap16To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap16To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap19To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap19To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap7To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap7To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap9To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap9To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap10To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + + protected SetMultimap10To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + } + } + + protected static class SetMultimap3To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap3To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap8To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap8To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap21To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap21To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap1To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap1To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap20To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap20To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap4To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap4To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap4To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap4To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap0To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap0To5Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap6To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap6To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap4To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap4To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap4To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap4To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap3To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap3To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap0To8Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap9To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap9To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap5To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap5To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap22To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap22To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap1To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap1To56Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap13To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap13To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap2To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap14To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap14To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap10To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap10To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap7To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap7To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap21To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap21To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap8To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap8To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap8To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap8To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap3To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap3To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap11To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap11To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap15To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap15To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap19To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap19To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap1To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap1To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap11To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap11To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap12To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap12To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap10To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap10To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap7To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + + protected SetMultimap7To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + } + } + + protected static class SetMultimap6To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap6To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap6To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap6To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap17To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap17To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap9To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap9To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap3To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap3To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap24To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap24To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap26To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + + protected SetMultimap26To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap7To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap7To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap5To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap5To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap5To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap5To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap1To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + + protected SetMultimap1To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + } + } + + protected static class SetMultimap17To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap17To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap29To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap29To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap14To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap14To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap2To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + + protected SetMultimap2To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap19To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap19To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap11To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap11To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap1To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap1To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap6To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap6To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap1To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap1To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap0To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap0To7Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap12To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap12To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap23To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + + protected SetMultimap23To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + } + } + + protected static class SetMultimap8To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap8To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap18To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap18To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap0To62Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 62; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 61 * addressSize; + + static final long nodeBase = rareBase + 62 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + + protected SetMultimap0To62Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59, + final Object slot60, final Object slot61) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + } + } + + protected static class SetMultimap21To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap21To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap2To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap2To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap10To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap10To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap12To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap12To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap4To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap4To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap16To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap16To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap5To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + + protected SetMultimap5To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + } + } + + protected static class SetMultimap0To64Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 64; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 63 * addressSize; + + static final long nodeBase = rareBase + 64 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + private final Object slot62; + private final Object slot63; + + protected SetMultimap0To64Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59, + final Object slot60, final Object slot61, final Object slot62, final Object slot63) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + this.slot62 = slot62; + this.slot63 = slot63; + } + } + + protected static class SetMultimap15To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap15To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap0To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap0To33Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap8To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap8To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap10To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap10To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap7To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap7To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap13To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap13To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap20To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + + protected SetMultimap20To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + } + } + + protected static class SetMultimap3To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap3To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap13To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap13To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap3To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap3To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap8To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap8To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap6To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap6To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap15To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap15To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap27To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + + protected SetMultimap27To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + } + } + + protected static class SetMultimap7To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap7To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap7To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap7To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap14To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap14To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap4To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap4To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap2To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap2To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap18To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap18To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap22To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap22To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap3To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap10To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap10To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap9To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap9To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap11To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap11To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap5To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap5To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap0To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap0To10Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap15To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap15To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap22To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap22To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap2To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap2To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap2To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap2To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap17To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap17To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap9To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + + protected SetMultimap9To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + } + } + + protected static class SetMultimap10To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap10To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap0To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap0To35Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap19To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap19To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap19To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap19To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap12To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap12To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap4To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap4To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap1To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap1To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap24To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap24To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap3To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap17To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap17To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap25To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap25To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap13To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + + protected SetMultimap13To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + } + } + + protected static class SetMultimap22To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap22To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap16To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + + protected SetMultimap16To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + } + } + + protected static class SetMultimap6To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + + protected SetMultimap6To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap24To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap24To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap19To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap19To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap18To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap18To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap0To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap0To16Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap20To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap20To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap4To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap4To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap15To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap15To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap7To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap7To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap23To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap23To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap10To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap10To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap0To60Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 60; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 59 * addressSize; + + static final long nodeBase = rareBase + 60 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + + protected SetMultimap0To60Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + } + } + + protected static class SetMultimap14To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap14To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap13To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap13To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap5To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap5To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap3To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap3To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap2To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap2To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap1To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap1To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap8To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap8To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap11To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap11To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap15To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap15To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap6To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap6To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap1To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap1To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap4To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap4To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap4To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap4To55Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap12To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap12To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap26To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap26To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap5To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap5To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap30To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + + protected SetMultimap30To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + } + } + + protected static class SetMultimap0To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap0To36Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap7To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap7To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap13To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap13To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap12To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap12To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap1To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap1To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap6To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap6To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap4To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap4To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap7To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap7To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap27To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap27To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap3To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap1To60Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 60; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 59 * addressSize; + + static final long nodeBase = rareBase + 60 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + + protected SetMultimap1To60Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58, + final Object slot59) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + } + } + + protected static class SetMultimap8To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap8To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap6To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap6To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap16To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap16To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap0To25Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap18To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap18To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap5To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap5To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap19To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap19To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap15To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + + protected SetMultimap15To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap12To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap12To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap18To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap18To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap9To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap9To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap14To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap14To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap4To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap4To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap10To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap10To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap27To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap27To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap9To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap9To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap10To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap10To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap2To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap2To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap13To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap13To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap4To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap4To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap3To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap3To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap11To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap11To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap21To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap21To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap1To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap1To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap12To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap12To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap9To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap9To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap3To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap3To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap23To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap23To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap27To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap27To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap10To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap10To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap6To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap6To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap9To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap9To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap4To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap4To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap8To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap8To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap8To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap8To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap18To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap18To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap14To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap14To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap5To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap5To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap20To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap20To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap0To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap0To22Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap2To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap25To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap25To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap14To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap14To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap11To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap11To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap7To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap7To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap17To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap17To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap22To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + + protected SetMultimap22To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap13To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap13To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap16To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap16To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap13To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap13To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap1To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap1To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap6To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap6To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap26To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap26To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap8To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap8To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap24To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + + protected SetMultimap24To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap5To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap5To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap10To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap10To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap5To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap5To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap14To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap14To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap27To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap27To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap6To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap6To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap26To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap26To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap5To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap5To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap0To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap0To47Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap4To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap4To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap2To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap2To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap0To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + protected SetMultimap0To0Node(final AtomicReference mutator, final long bitmap) { + super(mutator, bitmap); + + } + } + + protected static class SetMultimap3To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap3To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap13To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap13To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap1To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap1To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap7To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap7To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap10To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + + protected SetMultimap10To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + } + } + + protected static class SetMultimap7To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap7To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap23To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap23To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap12To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap12To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap2To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap2To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap18To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap18To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap4To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap4To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap0To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap0To18Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap1To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap1To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap16To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap16To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap20To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap20To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap1To62Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 62; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 61 * addressSize; + + static final long nodeBase = rareBase + 62 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + + protected SetMultimap1To62Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58, + final Object slot59, final Object slot60, final Object slot61) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + } + } + + protected static class SetMultimap8To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + + protected SetMultimap8To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap24To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap24To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap15To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap15To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap22To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap22To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap9To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap9To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap21To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap21To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap11To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + + protected SetMultimap11To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + } + } + + protected static class SetMultimap15To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap15To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap29To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + + protected SetMultimap29To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + } + } + + protected static class SetMultimap7To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap7To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap2To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap2To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap2To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap2To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap5To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap5To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap3To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap11To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap11To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap0To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap0To49Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap13To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap13To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap3To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + + protected SetMultimap3To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + } + } + + protected static class SetMultimap19To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap19To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap0To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap0To56Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap1To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap1To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap17To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + + protected SetMultimap17To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + } + } + + protected static class SetMultimap14To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap14To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap31To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 31; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 62 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final K key31; + private final V val31; + private final Object slot0; + private final Object slot1; + + protected SetMultimap31To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final K key31, final V val31, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap13To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap13To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap4To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap4To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap25To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + + protected SetMultimap25To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + } + } + + protected static class SetMultimap9To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap9To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap8To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap8To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap15To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap15To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap22To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap22To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap1To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap1To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap7To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap7To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap18To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap18To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap26To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap26To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap12To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap12To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap16To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap16To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap6To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap6To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap5To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap5To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap11To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap11To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap1To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap1To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap0To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap0To42Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap13To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap13To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap10To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap10To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap2To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap2To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap23To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap23To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap13To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap13To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap12To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap12To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap3To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap3To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap9To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap9To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap20To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + + protected SetMultimap20To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + } + } + + protected static class SetMultimap5To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap5To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap18To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap18To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap12To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap12To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap8To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap8To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap28To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap28To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap3To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap11To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap11To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap14To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap14To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap7To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap7To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap0To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap0To15Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap16To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap16To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap8To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap8To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap20To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap20To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap5To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + + protected SetMultimap5To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + } + } + + protected static class SetMultimap6To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap6To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap21To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap21To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap2To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap2To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap1To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + + protected SetMultimap1To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + } + } + + protected static class SetMultimap17To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap17To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap15To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap15To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap19To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + + protected SetMultimap19To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap25To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap25To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap17To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap17To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap4To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap4To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap0To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap0To53Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap10To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap10To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap2To59Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 59; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 58 * addressSize; + + static final long nodeBase = rareBase + 59 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + + protected SetMultimap2To59Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57, final Object slot58) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + } + } + + protected static class SetMultimap25To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap25To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap14To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap14To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap23To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + + protected SetMultimap23To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + } + } + + protected static class SetMultimap11To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap11To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap3To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap3To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap7To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + + protected SetMultimap7To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + } + } + + protected static class SetMultimap4To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap4To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap8To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap8To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap0To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap0To43Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap24To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap24To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap7To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap7To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap14To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap14To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap27To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap27To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap12To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap12To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap2To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap2To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap16To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap16To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap2To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap18To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap18To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap8To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap8To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap6To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap6To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap9To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap9To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap10To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap10To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap10To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap10To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap9To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap9To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap1To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap1To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap21To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap21To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap11To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap11To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap6To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap6To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap17To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap17To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap22To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap22To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap5To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap5To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap12To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap12To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap25To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap25To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap18To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap18To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap15To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap15To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap3To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap3To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap14To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap14To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap0To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap0To29Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap1To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap1To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap6To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap6To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap12To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap12To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap14To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap14To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap8To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap8To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap1To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap1To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap7To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap7To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap21To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + + protected SetMultimap21To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap4To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap4To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap4To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap4To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap11To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap11To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap5To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap5To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap6To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap6To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap2To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap2To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap22To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap22To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap10To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap10To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap25To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap25To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap3To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap3To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap17To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap17To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap11To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap11To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap24To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap24To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap28To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap28To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap15To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap15To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap16To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + + protected SetMultimap16To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + } + } + + protected static class SetMultimap5To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap5To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap13To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + + protected SetMultimap13To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + } + } + + protected static class SetMultimap2To57Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 57; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected SetMultimap2To57Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class SetMultimap3To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap3To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap16To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap16To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap19To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap19To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap0To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap0To30Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap15To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap15To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap0To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap0To54Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap1To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap1To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap4To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap4To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap5To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap5To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap7To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap7To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap17To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap17To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap8To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap8To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap18To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap18To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap12To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap12To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap6To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap6To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap27To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + + protected SetMultimap27To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + } + } + + protected static class SetMultimap2To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap2To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap4To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap4To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap3To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap3To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap10To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap10To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap2To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap2To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap0To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap0To12Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap6To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap6To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap9To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + + protected SetMultimap9To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + } + } + + protected static class SetMultimap20To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap20To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap11To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap11To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap7To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap7To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap19To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap19To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap9To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap9To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap14To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap14To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap6To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap6To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap7To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap7To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap2To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap2To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap8To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap8To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap23To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap23To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap5To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap5To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap5To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap5To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap20To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap20To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap1To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap1To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap0To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap0To46Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap7To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap7To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap28To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + + protected SetMultimap28To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + } + } + + protected static class SetMultimap19To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap19To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap23To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap23To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap2To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap2To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap8To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + + protected SetMultimap8To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + } + } + + protected static class SetMultimap15To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap15To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap14To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + + protected SetMultimap14To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + } + } + + protected static class SetMultimap20To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap20To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap10To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap10To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap13To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap13To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap9To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap9To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap14To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap14To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap0To59Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 59; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 58 * addressSize; + + static final long nodeBase = rareBase + 59 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + + protected SetMultimap0To59Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + } + } + + protected static class SetMultimap21To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap21To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap4To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap4To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap2To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap1To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap1To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap16To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap16To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap3To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap3To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap0To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap0To23Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap23To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap23To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap7To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap7To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap19To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap19To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap3To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap3To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap24To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap24To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap13To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap13To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap2To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap2To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap10To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap10To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap9To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap9To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap20To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap20To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap18To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + + protected SetMultimap18To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + } + } + + protected static class SetMultimap7To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap7To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap8To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap8To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap25To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + + protected SetMultimap25To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap19To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap19To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap22To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap22To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap17To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + + protected SetMultimap17To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap31To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 31; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 62 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final K key31; + private final V val31; + private final Object slot0; + + protected SetMultimap31To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final K key31, final V val31, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + this.slot0 = slot0; + } + } + + protected static class SetMultimap0To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap0To44Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap16To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap16To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap6To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap6To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap0To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap0To24Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap5To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap5To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap2To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap2To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap11To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + + protected SetMultimap11To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap21To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap21To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap1To58Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 58; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected SetMultimap1To58Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class SetMultimap18To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap18To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap3To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + + protected SetMultimap3To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap12To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap12To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap1To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap1To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap4To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap4To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap5To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap5To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap10To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap10To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap4To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap4To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap12To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + + protected SetMultimap12To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + } + } + + protected static class SetMultimap1To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap1To55Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap1To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap1To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap1To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap1To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap5To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap5To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap0To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap0To21Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap5To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap5To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap21To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap21To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap20To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap20To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap12To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap12To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap0To57Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 57; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected SetMultimap0To57Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class SetMultimap23To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap23To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap8To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap8To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap6To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap6To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap26To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap26To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap11To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap3To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap3To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap8To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap8To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap15To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + + protected SetMultimap15To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + } + } + + protected static class SetMultimap11To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap11To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap11To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap11To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap4To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap4To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap3To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap3To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap3To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap3To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap9To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap9To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap1To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap1To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap25To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap25To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap9To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap9To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap16To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap16To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap17To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap17To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap18To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap18To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap2To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap13To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap13To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap17To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap17To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap4To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap4To56Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap14To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap14To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap10To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap10To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap14To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap14To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap19To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap19To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap7To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap7To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap16To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap16To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap6To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap6To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap1To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap1To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap4To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap4To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap4To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap4To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap0To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap0To19Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap21To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap21To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap9To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap9To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap16To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap16To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap2To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap2To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap0To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap0To26Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap14To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap14To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap19To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap19To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap9To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap9To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap3To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap22To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + + protected SetMultimap22To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + } + } + + protected static class SetMultimap6To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap6To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap12To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap12To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap4To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + + protected SetMultimap4To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + } + } + + protected static class SetMultimap12To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap12To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap5To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap5To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap10To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap10To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap6To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap6To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap21To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap21To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap18To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap18To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap24To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + + protected SetMultimap24To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + } + } + + protected static class SetMultimap17To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap17To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap13To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap13To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap11To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap11To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap7To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap7To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap2To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap2To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap10To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap10To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap22To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap22To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap10To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap10To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap6To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + + protected SetMultimap6To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + } + } + + protected static class SetMultimap2To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap2To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap21To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + + protected SetMultimap21To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + } + } + + protected static class SetMultimap20To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap20To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap0To63Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 63; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 62 * addressSize; + + static final long nodeBase = rareBase + 63 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + private final Object slot62; + + protected SetMultimap0To63Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59, + final Object slot60, final Object slot61, final Object slot62) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + this.slot62 = slot62; + } + } + + protected static class SetMultimap18To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap18To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap11To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap12To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap12To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap8To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap8To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap24To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap24To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap17To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap17To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap4To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap4To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap19To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap19To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap15To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap15To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap9To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap9To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap4To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap4To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap14To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap14To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap9To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap9To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap5To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap5To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap13To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + + protected SetMultimap13To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap30To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap30To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap7To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap7To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap7To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap7To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap24To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap24To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap6To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap6To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap1To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap1To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap2To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap2To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap22To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap22To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap6To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap6To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap16To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap16To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap7To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap7To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap15To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap15To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap3To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap3To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap0To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap0To6Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap16To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap16To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap24To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap24To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap1To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap1To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap20To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap20To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap8To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap8To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap4To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap4To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap3To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap3To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap12To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap12To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap22To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap22To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap17To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap17To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap15To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap15To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap25To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap25To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap2To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap2To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap4To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap4To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap0To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap0To32Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap29To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap29To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap6To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap6To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap27To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + + protected SetMultimap27To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap8To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap8To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap5To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap5To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap14To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap14To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap15To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap15To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap3To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap3To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap10To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap10To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap5To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap5To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap5To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap5To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap7To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap7To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap9To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap9To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap4To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap4To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap9To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap9To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap11To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap11To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap1To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap1To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap1To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap1To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap9To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap9To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap16To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap16To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap3To58Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 58; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected SetMultimap3To58Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class SetMultimap0To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap0To17Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap4To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap4To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap11To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap21To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap21To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap10To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap10To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap24To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap24To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap25To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap25To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap5To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap5To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap12To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap12To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap2To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap2To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap27To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap27To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap13To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap13To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap5To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + + protected SetMultimap5To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap11To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap11To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap10To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap10To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap20To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap20To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap8To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap8To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap19To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + + protected SetMultimap19To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + } + } + + protected static class SetMultimap1To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + + protected SetMultimap1To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap3To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap3To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap3To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap3To55Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap3To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap3To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap2To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + + protected SetMultimap2To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + } + } + + protected static class SetMultimap14To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap14To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap0To4Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap8To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap8To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap7To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap7To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap17To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap17To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap9To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap9To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap1To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap1To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap6To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap6To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap15To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap15To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap4To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap4To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap6To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap6To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap2To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap2To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap22To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap22To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap13To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap13To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap9To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap9To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap16To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap16To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap8To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap8To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap0To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap0To11Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap1To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap1To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap11To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap11To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap5To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap5To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap18To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap18To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap3To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap3To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap10To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap10To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap10To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap10To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap26To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + + protected SetMultimap26To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + } + } + + protected static class SetMultimap6To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap6To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap24To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap24To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap7To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + + protected SetMultimap7To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap22To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap22To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap16To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap16To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap15To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap15To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap4To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap4To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap29To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap29To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap14To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap14To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap0To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap0To34Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap8To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap8To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap3To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap3To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap11To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap11To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap12To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap12To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap2To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap2To56Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap0To61Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 61; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 60 * addressSize; + + static final long nodeBase = rareBase + 61 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + + protected SetMultimap0To61Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59, + final Object slot60) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + } + } + + protected static class SetMultimap2To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap2To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap20To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap20To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap13To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap13To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap13To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap13To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specializations_Path_Interlinked.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specializations_Path_Interlinked.java new file mode 100644 index 0000000..40dfa2a --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specializations_Path_Interlinked.java @@ -0,0 +1,124448 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.multimap; + +import java.util.concurrent.atomic.AtomicReference; + +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.CompactSetMultimapNode; + +import static io.usethesource.capsule.util.DataLayoutHelper.addressSize; + +@SuppressWarnings({"rawtypes", "restriction"}) +public class TrieSetMultimap_HHAMT_Specializations_Path_Interlinked { + + protected static class SetMultimap12To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + + protected SetMultimap12To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + } + } + + protected static class SetMultimap29To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + + protected SetMultimap29To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap6To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap6To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap2To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap2To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap27To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap27To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap2To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap2To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap1To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap1To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap1To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap1To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap5To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap5To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap6To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap6To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap20To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap20To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap4To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap4To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap3To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap3To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap1To61Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 61; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 60 * addressSize; + + static final long nodeBase = rareBase + 61 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + + protected SetMultimap1To61Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58, + final Object slot59, final Object slot60) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + } + } + + protected static class SetMultimap23To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap23To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap18To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + + protected SetMultimap18To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + } + } + + protected static class SetMultimap17To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap17To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap4To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap4To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap26To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap26To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap7To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap7To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap15To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap15To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap5To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap5To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap12To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap12To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap11To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap11To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap31To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 31; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 62 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final K key31; + private final V val31; + + protected SetMultimap31To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final K key31, final V val31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + } + } + + protected static class SetMultimap7To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap7To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap16To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap16To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap3To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap3To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap0To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap0To45Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap13To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap13To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap21To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap21To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap9To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap9To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap6To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap6To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap1To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap1To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap15To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap15To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap10To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + + protected SetMultimap10To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap5To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap5To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap3To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap3To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap3To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap26To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap26To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap7To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap7To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap11To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap11To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap8To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap8To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap8To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap8To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap1To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap1To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap0To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final Object slot0; + private final Object slot1; + + protected SetMultimap0To2Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap5To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap5To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap2To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap2To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap16To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap16To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap28To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + + protected SetMultimap28To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + } + } + + protected static class SetMultimap9To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap9To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap26To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap26To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap4To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap4To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap2To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap2To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap19To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap19To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap13To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap13To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap0To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap0To51Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap7To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap7To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap8To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + + protected SetMultimap8To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + } + } + + protected static class SetMultimap17To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap17To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap14To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + + protected SetMultimap14To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + } + } + + protected static class SetMultimap9To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap9To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap12To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap12To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap2To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap2To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap11To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap11To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap8To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap8To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap3To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap3To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap27To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap27To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap10To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap10To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap19To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap19To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap1To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap1To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap12To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap12To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap24To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + + protected SetMultimap24To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + } + } + + protected static class SetMultimap6To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap6To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap0To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap0To9Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap7To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap7To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap13To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap13To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap22To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + + protected SetMultimap22To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + } + } + + protected static class SetMultimap13To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap13To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap0To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap0To38Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap0To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap0To27Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap9To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap9To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap18To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap18To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap4To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap4To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap16To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap16To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap3To57Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 57; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected SetMultimap3To57Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class SetMultimap2To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap2To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap6To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap6To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap5To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap5To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap22To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap22To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap10To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap10To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap10To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap10To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap4To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + + protected SetMultimap4To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + } + } + + protected static class SetMultimap17To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap17To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap5To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap5To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap9To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap9To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap8To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap8To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap17To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap17To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap9To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap9To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap13To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap13To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap20To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap20To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap2To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap2To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap11To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap11To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap26To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap26To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap23To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap23To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap6To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap6To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap13To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap13To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap17To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap17To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap16To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap16To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap8To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap8To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap1To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap1To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap2To60Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 60; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 59 * addressSize; + + static final long nodeBase = rareBase + 60 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + + protected SetMultimap2To60Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57, final Object slot58, final Object slot59) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + } + } + + protected static class SetMultimap21To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap21To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap11To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap11To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap6To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap6To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap10To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap10To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap30To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final Object slot0; + private final Object slot1; + + protected SetMultimap30To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap7To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap7To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap3To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap3To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap3To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap3To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap15To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap15To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap4To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap4To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap28To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap28To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap0To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap0To20Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap15To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + + protected SetMultimap15To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + } + } + + protected static class SetMultimap14To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap14To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap5To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap5To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap17To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap17To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap14To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap14To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap25To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap25To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap1To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap1To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap4To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap4To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap22To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap22To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap2To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap2To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap9To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + + protected SetMultimap9To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap6To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap6To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap1To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap1To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap20To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap20To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap10To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap10To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap24To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap24To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap7To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap7To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap26To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap26To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap19To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap19To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap8To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap8To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap11To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap14To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap14To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap13To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap13To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap3To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap3To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap0To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap0To28Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap23To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap23To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap12To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap12To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap18To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap18To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap5To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap5To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap15To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap15To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap4To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap4To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap14To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap14To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap13To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap13To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap11To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap11To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap1To57Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 57; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected SetMultimap1To57Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class SetMultimap12To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap12To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap6To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap6To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap4To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap4To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap21To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + + protected SetMultimap21To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + } + } + + protected static class SetMultimap0To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap0To14Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap9To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap9To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap12To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap12To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap10To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap10To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap3To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap3To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap7To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap7To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap20To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap20To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap19To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap19To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap2To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap2To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap15To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap15To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap0To52Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap7To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap7To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap8To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap8To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap6To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + + protected SetMultimap6To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + } + } + + protected static class SetMultimap5To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap5To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap2To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap2To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap16To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + + protected SetMultimap16To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap4To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap4To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap1To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap1To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap21To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap21To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap18To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap18To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap4To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap4To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap11To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap11To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap13To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap13To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap16To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap16To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap26To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + + protected SetMultimap26To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + } + } + + protected static class SetMultimap2To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap2To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap12To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap12To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap13To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap13To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap7To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap7To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap10To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap10To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap1To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap1To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap8To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap8To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap5To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap5To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap8To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap8To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap0To58Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 58; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected SetMultimap0To58Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class SetMultimap18To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap18To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap25To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap25To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap0To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap0To13Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap12To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap12To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap17To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap17To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap3To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap21To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap21To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap6To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap6To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap0To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap0To40Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap0To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap0To55Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap3To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap3To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap17To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap17To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap28To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap28To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap16To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap16To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap7To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap7To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap9To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap9To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap14To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap14To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap11To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap11To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap15To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap15To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap1To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap1To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap14To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap14To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap28To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap28To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap5To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap5To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap10To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap10To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap4To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap4To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap11To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap11To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap1To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap1To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap0To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap0To31Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap5To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap5To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap12To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap12To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap23To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + + protected SetMultimap23To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap17To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap17To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap22To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap22To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap2To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap2To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap3To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap3To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap18To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap18To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap8To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap8To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap12To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap12To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap3To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap1To59Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 59; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 58 * addressSize; + + static final long nodeBase = rareBase + 59 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + + protected SetMultimap1To59Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + } + } + + protected static class SetMultimap7To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap7To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap11To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap11To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap7To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap7To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap6To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap6To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap5To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap5To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap14To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap14To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap9To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap9To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap20To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + + protected SetMultimap20To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap9To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap9To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap8To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap8To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap2To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + + protected SetMultimap2To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + } + } + + protected static class SetMultimap0To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap0To41Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap1To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap1To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap18To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap18To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap25To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap25To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap19To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap19To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap9To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap9To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap16To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap16To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap4To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap4To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap13To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap13To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap24To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap24To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap10To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap10To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap19To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + + protected SetMultimap19To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + } + } + + protected static class SetMultimap14To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap14To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap10To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap10To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap6To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap6To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap15To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap15To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap28To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap28To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap14To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap14To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap3To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap3To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap11To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap11To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap16To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap16To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap9To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap9To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap21To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap21To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap15To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap15To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap4To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + + protected SetMultimap4To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap8To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap8To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap4To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap4To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap5To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap5To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap12To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap12To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap6To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap6To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap2To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap2To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap1To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap1To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap11To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap13To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap13To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap16To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap16To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap20To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap20To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap5To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap5To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap3To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap3To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap1To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap1To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap29To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap29To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap6To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap6To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap17To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap17To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap7To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap7To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap8To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap8To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap14To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap14To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap18To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap18To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap9To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap9To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap0To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap0To50Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap23To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap23To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap20To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap20To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap10To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap10To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap9To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap9To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap0To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap0To3Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap9To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap9To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap3To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap8To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap8To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap0To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap0To37Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap2To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap2To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap6To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap6To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap15To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap15To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap21To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap21To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap30To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final Object slot0; + + protected SetMultimap30To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + } + } + + protected static class SetMultimap12To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap12To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap12To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap12To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap4To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap4To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap14To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap14To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap18To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap18To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap16To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap16To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap1To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap1To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap21To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap21To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap5To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap5To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap11To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap11To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap32To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 32; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 64 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final K key31; + private final V val31; + private final K key32; + private final V val32; + + protected SetMultimap32To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final K key31, final V val31, final K key32, final V val32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + this.key32 = key32; + this.val32 = val32; + } + } + + protected static class SetMultimap6To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap6To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap10To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap10To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap13To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap13To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap19To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap19To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap23To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap23To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap12To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap12To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap17To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap17To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap18To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap18To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap2To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap2To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap7To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap7To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap17To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap17To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap23To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap23To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap19To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap19To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap1To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap1To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap1To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap1To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap23To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap23To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap18To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + + protected SetMultimap18To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap11To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap11To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap20To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap20To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + + protected SetMultimap3To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + } + } + + protected static class SetMultimap11To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + + protected SetMultimap11To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + } + } + + protected static class SetMultimap2To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap2To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap2To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap2To55Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap4To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap4To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap7To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap7To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap0To48Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap25To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + + protected SetMultimap25To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + } + } + + protected static class SetMultimap8To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap8To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap15To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap15To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap5To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap5To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap2To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap2To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap17To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + + protected SetMultimap17To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + } + } + + protected static class SetMultimap2To58Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 58; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected SetMultimap2To58Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class SetMultimap8To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap8To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap6To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap6To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap7To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap7To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap5To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap5To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap13To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap13To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap3To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap3To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap15To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap15To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap12To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + + protected SetMultimap12To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap9To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap9To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap3To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap3To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap29To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + + protected SetMultimap29To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + } + } + + protected static class SetMultimap16To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap16To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap20To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap20To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap6To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap6To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap3To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap3To56Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap9To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap9To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap4To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap4To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap5To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap5To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap14To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + + protected SetMultimap14To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap15To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap15To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap22To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap22To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap28To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + + protected SetMultimap28To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap1To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap1To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap7To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap7To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap0To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap0To39Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap5To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap5To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap30To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap30To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap8To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap8To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap5To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap5To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final Object slot0; + + protected SetMultimap0To1Node(final AtomicReference mutator, final long bitmap, + final Object slot0) { + super(mutator, bitmap); + this.slot0 = slot0; + } + } + + protected static class SetMultimap2To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap2To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap19To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap19To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap10To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap10To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap23To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap23To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap2To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap2To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap13To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap13To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap6To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap6To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap1To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap1To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap16To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap16To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap19To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap19To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap7To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap7To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap9To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap9To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap10To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + + protected SetMultimap10To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + } + } + + protected static class SetMultimap3To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap3To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap8To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap8To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap21To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap21To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap1To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap1To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap20To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap20To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap4To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap4To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap4To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap4To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap0To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap0To5Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap6To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap6To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap4To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap4To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap4To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap4To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap3To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap3To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap0To8Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap9To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap9To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap5To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap5To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap22To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap22To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap1To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap1To56Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap13To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap13To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap2To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap14To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap14To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap10To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap10To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap7To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap7To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap21To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap21To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap8To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap8To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap8To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap8To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap3To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap3To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap11To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap11To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap15To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap15To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap19To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap19To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap1To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap1To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap11To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap11To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap12To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap12To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap10To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap10To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap7To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + + protected SetMultimap7To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + } + } + + protected static class SetMultimap6To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap6To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap6To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap6To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap17To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap17To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap9To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap9To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap3To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap3To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap24To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap24To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap26To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + + protected SetMultimap26To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap7To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap7To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap5To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap5To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap5To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap5To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap1To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + + protected SetMultimap1To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + } + } + + protected static class SetMultimap17To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap17To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap29To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap29To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap14To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap14To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap2To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + + protected SetMultimap2To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap19To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap19To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap11To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap11To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap1To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap1To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap6To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap6To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap1To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap1To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap0To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap0To7Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap12To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap12To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap23To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + + protected SetMultimap23To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + } + } + + protected static class SetMultimap8To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap8To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap18To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap18To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap0To62Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 62; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 61 * addressSize; + + static final long nodeBase = rareBase + 62 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + + protected SetMultimap0To62Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59, + final Object slot60, final Object slot61) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + } + } + + protected static class SetMultimap21To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap21To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap2To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap2To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap10To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap10To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap12To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap12To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap4To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap4To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap16To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap16To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap5To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + + protected SetMultimap5To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + } + } + + protected static class SetMultimap0To64Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 64; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 63 * addressSize; + + static final long nodeBase = rareBase + 64 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + private final Object slot62; + private final Object slot63; + + protected SetMultimap0To64Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59, + final Object slot60, final Object slot61, final Object slot62, final Object slot63) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + this.slot62 = slot62; + this.slot63 = slot63; + } + } + + protected static class SetMultimap15To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap15To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap0To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap0To33Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap8To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap8To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap10To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap10To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap7To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap7To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap13To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap13To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap20To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + + protected SetMultimap20To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + } + } + + protected static class SetMultimap3To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap3To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap13To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap13To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap3To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap3To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap8To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap8To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap6To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap6To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap15To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap15To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap27To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + + protected SetMultimap27To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + } + } + + protected static class SetMultimap7To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap7To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap7To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap7To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap14To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap14To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap4To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap4To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap2To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap2To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap18To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap18To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap22To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap22To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap3To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap10To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap10To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap9To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap9To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap11To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap11To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap5To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap5To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap0To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap0To10Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap15To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap15To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap22To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap22To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap2To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap2To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap2To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap2To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap17To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap17To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap9To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + + protected SetMultimap9To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + } + } + + protected static class SetMultimap10To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap10To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap0To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap0To35Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap19To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap19To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap19To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap19To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap12To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap12To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap4To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap4To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap1To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap1To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap24To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap24To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap3To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap17To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap17To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap25To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap25To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap13To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + + protected SetMultimap13To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + } + } + + protected static class SetMultimap22To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap22To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap16To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + + protected SetMultimap16To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + } + } + + protected static class SetMultimap6To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + + protected SetMultimap6To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap24To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap24To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap19To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap19To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap18To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap18To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap0To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap0To16Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap20To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap20To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap4To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap4To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap15To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap15To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap7To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap7To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap23To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap23To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap10To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap10To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap0To60Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 60; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 59 * addressSize; + + static final long nodeBase = rareBase + 60 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + + protected SetMultimap0To60Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + } + } + + protected static class SetMultimap14To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap14To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap13To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap13To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap5To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap5To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap3To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap3To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap2To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap2To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap1To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap1To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap8To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap8To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap11To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap11To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap15To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap15To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap6To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap6To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap1To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap1To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap4To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap4To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap4To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap4To55Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap12To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap12To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap26To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap26To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap5To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap5To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap30To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + + protected SetMultimap30To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + } + } + + protected static class SetMultimap0To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap0To36Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap7To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap7To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap13To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap13To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap12To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap12To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap1To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap1To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap6To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap6To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap4To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap4To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap7To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap7To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap27To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap27To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap3To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap1To60Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 60; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 59 * addressSize; + + static final long nodeBase = rareBase + 60 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + + protected SetMultimap1To60Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58, + final Object slot59) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + } + } + + protected static class SetMultimap8To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap8To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap6To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap6To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap16To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap16To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap0To25Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap18To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap18To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap5To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap5To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap19To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap19To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap15To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + + protected SetMultimap15To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap12To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap12To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap18To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap18To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap9To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap9To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap14To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap14To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap4To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap4To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap10To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap10To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap27To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap27To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap9To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap9To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap10To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap10To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap2To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap2To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap13To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap13To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap4To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap4To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap3To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap3To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap11To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap11To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap21To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap21To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap1To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap1To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap12To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap12To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap9To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap9To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap3To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap3To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap23To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap23To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap27To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap27To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap10To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap10To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap6To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap6To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap9To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap9To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap4To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap4To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap8To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap8To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap8To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap8To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap18To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap18To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap14To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap14To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap5To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap5To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap20To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap20To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap0To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap0To22Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap2To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap25To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap25To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap14To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap14To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap11To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap11To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap7To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap7To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap17To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap17To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap22To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + + protected SetMultimap22To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap13To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap13To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap16To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap16To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap13To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap13To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap1To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap1To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap6To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap6To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap26To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap26To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap8To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap8To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap24To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + + protected SetMultimap24To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap5To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap5To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap10To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap10To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap5To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap5To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap14To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap14To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap27To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap27To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap6To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap6To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap26To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap26To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap5To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap5To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap0To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap0To47Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap4To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap4To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap2To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap2To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap0To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + protected SetMultimap0To0Node(final AtomicReference mutator, final long bitmap) { + super(mutator, bitmap); + + } + } + + protected static class SetMultimap3To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap3To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap13To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap13To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap1To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap1To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap7To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap7To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap10To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + + protected SetMultimap10To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + } + } + + protected static class SetMultimap7To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap7To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap23To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap23To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap12To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap12To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap2To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap2To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap18To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap18To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap4To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap4To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap0To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap0To18Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap1To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap1To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap16To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap16To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap20To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap20To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap1To62Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 62; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 61 * addressSize; + + static final long nodeBase = rareBase + 62 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + + protected SetMultimap1To62Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57, final Object slot58, + final Object slot59, final Object slot60, final Object slot61) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + } + } + + protected static class SetMultimap8To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + + protected SetMultimap8To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap24To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap24To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap15To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap15To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap22To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap22To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap9To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap9To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap21To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap21To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap11To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + + protected SetMultimap11To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + } + } + + protected static class SetMultimap15To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap15To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap29To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + + protected SetMultimap29To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + } + } + + protected static class SetMultimap7To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap7To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap2To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap2To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap2To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap2To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap5To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap5To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap3To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap3To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap11To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap11To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap0To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap0To49Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap13To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap13To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap3To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + + protected SetMultimap3To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + } + } + + protected static class SetMultimap19To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap19To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap0To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap0To56Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap1To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap1To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap17To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + + protected SetMultimap17To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + } + } + + protected static class SetMultimap14To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap14To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap31To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 31; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 62 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final K key31; + private final V val31; + private final Object slot0; + private final Object slot1; + + protected SetMultimap31To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final K key31, final V val31, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap13To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap13To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap4To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap4To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap25To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + + protected SetMultimap25To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + } + } + + protected static class SetMultimap9To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap9To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap8To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap8To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap15To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap15To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap22To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap22To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap1To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap1To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap7To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap7To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap18To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap18To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap26To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap26To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap12To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap12To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap16To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap16To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap6To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap6To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap5To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap5To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap11To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap11To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap1To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap1To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap0To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap0To42Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap13To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap13To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap10To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap10To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap2To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap2To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap23To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap23To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap13To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap13To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap12To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap12To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap3To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap3To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap9To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap9To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap20To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + + protected SetMultimap20To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + } + } + + protected static class SetMultimap5To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap5To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap18To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap18To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap12To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap12To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap8To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap8To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap28To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap28To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap3To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap11To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap11To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap14To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap14To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap7To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap7To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap0To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap0To15Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap16To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap16To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap8To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap8To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap20To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap20To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap5To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + + protected SetMultimap5To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + } + } + + protected static class SetMultimap6To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap6To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap21To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap21To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap2To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap2To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap1To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + + protected SetMultimap1To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + } + } + + protected static class SetMultimap17To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap17To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap15To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap15To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap19To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + + protected SetMultimap19To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap25To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap25To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap17To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap17To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap4To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap4To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap0To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap0To53Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap10To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap10To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap2To59Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 59; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 58 * addressSize; + + static final long nodeBase = rareBase + 59 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + + protected SetMultimap2To59Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56, + final Object slot57, final Object slot58) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + } + } + + protected static class SetMultimap25To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap25To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap14To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap14To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap23To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + + protected SetMultimap23To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + } + } + + protected static class SetMultimap11To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap11To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap3To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap3To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap7To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + + protected SetMultimap7To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + } + } + + protected static class SetMultimap4To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap4To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap8To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap8To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap0To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap0To43Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap24To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap24To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap7To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap7To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap14To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap14To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap27To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap27To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap12To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap12To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap2To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap2To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap16To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap16To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap2To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap18To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap18To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap8To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap8To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap6To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap6To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap9To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap9To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap10To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap10To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap10To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap10To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap9To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap9To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap1To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap1To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap21To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap21To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap11To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap11To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap6To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap6To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap17To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap17To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap22To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap22To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap5To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap5To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap12To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap12To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap25To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap25To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap18To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap18To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap15To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap15To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap3To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap3To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap14To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap14To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap0To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap0To29Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap1To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap1To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap6To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap6To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap12To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap12To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap14To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap14To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap8To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap8To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap1To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap1To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap7To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap7To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap21To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + + protected SetMultimap21To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap4To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap4To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap4To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap4To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap11To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap11To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap5To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap5To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap6To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap6To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap2To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap2To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap22To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap22To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap10To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap10To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap25To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap25To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap3To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap3To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap17To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap17To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap11To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap11To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap24To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap24To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap28To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap28To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap15To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap15To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap16To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + + protected SetMultimap16To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + } + } + + protected static class SetMultimap5To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap5To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap13To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + + protected SetMultimap13To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + } + } + + protected static class SetMultimap2To57Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 57; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected SetMultimap2To57Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55, final Object slot56) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class SetMultimap3To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap3To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap16To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap16To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap19To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap19To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap0To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap0To30Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap15To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap15To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap0To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap0To54Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap1To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap1To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap4To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap4To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap5To50Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 50; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 49 * addressSize; + + static final long nodeBase = rareBase + 50 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + + protected SetMultimap5To50Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + } + } + + protected static class SetMultimap7To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap7To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap17To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap17To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap8To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap8To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap18To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap18To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap12To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap12To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap6To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap6To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap27To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + + protected SetMultimap27To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + } + } + + protected static class SetMultimap2To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap2To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap4To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap4To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap3To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap3To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap10To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap10To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap2To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap2To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap0To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap0To12Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap6To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap6To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap9To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + + protected SetMultimap9To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + } + } + + protected static class SetMultimap20To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap20To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap11To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap11To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap7To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap7To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap19To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap19To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap9To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap9To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap14To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap14To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap6To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap6To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap7To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap7To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap2To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap2To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap8To39Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 39; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 38 * addressSize; + + static final long nodeBase = rareBase + 39 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + + protected SetMultimap8To39Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + } + } + + protected static class SetMultimap23To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap23To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap5To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap5To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap5To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap5To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap20To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap20To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap1To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap1To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap0To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap0To46Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap7To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap7To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap28To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 28; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 56 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + + protected SetMultimap28To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + } + } + + protected static class SetMultimap19To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap19To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap23To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap23To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap2To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap2To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap8To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + + protected SetMultimap8To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + } + } + + protected static class SetMultimap15To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap15To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap14To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + + protected SetMultimap14To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + } + } + + protected static class SetMultimap20To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap20To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap10To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap10To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap13To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap13To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap9To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap9To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap14To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap14To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap0To59Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 59; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 58 * addressSize; + + static final long nodeBase = rareBase + 59 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + + protected SetMultimap0To59Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + } + } + + protected static class SetMultimap21To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap21To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap4To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap4To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap2To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap1To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap1To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap16To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap16To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap3To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap3To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap0To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap0To23Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap23To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap23To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap7To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap7To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap19To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap19To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap3To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap3To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap24To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap24To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap13To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap13To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap2To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap2To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap10To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap10To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap9To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap9To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap20To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap20To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap18To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + + protected SetMultimap18To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + } + } + + protected static class SetMultimap7To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap7To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap8To48Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 48; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 47 * addressSize; + + static final long nodeBase = rareBase + 48 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + + protected SetMultimap8To48Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + } + } + + protected static class SetMultimap25To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + + protected SetMultimap25To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap19To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap19To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap22To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap22To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap17To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + + protected SetMultimap17To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap31To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 31; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 62 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final K key31; + private final V val31; + private final Object slot0; + + protected SetMultimap31To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final K key31, final V val31, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.key31 = key31; + this.val31 = val31; + this.slot0 = slot0; + } + } + + protected static class SetMultimap0To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap0To44Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap16To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap16To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap6To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap6To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap0To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap0To24Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap5To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap5To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap2To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap2To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap11To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + + protected SetMultimap11To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap21To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap21To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap1To58Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 58; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected SetMultimap1To58Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55, final Object slot56, final Object slot57) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class SetMultimap18To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap18To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap3To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + + protected SetMultimap3To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap12To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap12To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap1To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap1To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap4To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap4To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap5To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap5To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap10To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap10To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap4To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap4To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap12To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + + protected SetMultimap12To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + } + } + + protected static class SetMultimap1To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap1To55Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap1To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap1To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap1To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap1To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap5To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap5To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap0To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap0To21Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap5To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap5To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap21To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap21To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap20To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap20To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap12To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap12To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap0To57Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 57; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 56 * addressSize; + + static final long nodeBase = rareBase + 57 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + + protected SetMultimap0To57Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + } + } + + protected static class SetMultimap23To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 23; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 46 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap23To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap8To37Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 37; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 36 * addressSize; + + static final long nodeBase = rareBase + 37 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + + protected SetMultimap8To37Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + } + } + + protected static class SetMultimap6To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap6To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap26To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap26To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap11To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap3To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap3To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap8To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap8To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap15To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + + protected SetMultimap15To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + } + } + + protected static class SetMultimap11To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap11To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap11To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap11To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap4To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap4To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap3To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap3To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap3To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap3To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap9To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap9To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap1To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap1To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap25To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap25To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap9To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap9To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap16To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap16To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap17To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap17To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap18To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap18To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap2To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap2To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap13To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap13To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap17To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap17To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap4To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap4To56Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53, final Object slot54, + final Object slot55) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap14To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap14To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap10To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap10To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap14To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap14To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap19To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap19To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap7To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap7To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap16To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap16To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap6To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap6To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap1To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap1To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap4To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap4To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap4To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap4To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap0To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap0To19Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap21To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap21To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap9To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap9To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap16To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap16To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap2To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap2To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap0To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap0To26Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap14To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap14To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap19To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap19To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap9To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap9To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap3To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap3To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap22To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + + protected SetMultimap22To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + } + } + + protected static class SetMultimap6To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap6To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap12To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap12To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap4To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + + protected SetMultimap4To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + } + } + + protected static class SetMultimap12To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap12To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap5To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap5To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap10To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap10To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap6To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap6To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap21To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap21To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap18To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap18To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap24To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + + protected SetMultimap24To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + } + } + + protected static class SetMultimap17To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap17To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap13To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap13To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap11To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap11To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap7To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap7To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap2To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap2To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap10To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap10To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap22To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap22To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap10To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap10To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap6To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + + protected SetMultimap6To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + } + } + + protected static class SetMultimap2To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap2To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap21To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + + protected SetMultimap21To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + } + } + + protected static class SetMultimap20To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap20To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap0To63Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 63; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 62 * addressSize; + + static final long nodeBase = rareBase + 63 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + private final Object slot61; + private final Object slot62; + + protected SetMultimap0To63Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59, + final Object slot60, final Object slot61, final Object slot62) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + this.slot61 = slot61; + this.slot62 = slot62; + } + } + + protected static class SetMultimap18To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap18To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap11To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap12To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap12To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap8To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap8To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap24To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap24To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap17To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap17To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap4To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap4To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap19To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap19To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap15To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap15To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap9To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap9To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap4To43Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 43; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 42 * addressSize; + + static final long nodeBase = rareBase + 43 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + + protected SetMultimap4To43Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + } + } + + protected static class SetMultimap14To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap14To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap9To44Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 44; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 43 * addressSize; + + static final long nodeBase = rareBase + 44 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + + protected SetMultimap9To44Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + } + } + + protected static class SetMultimap5To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap5To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap13To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + + protected SetMultimap13To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap30To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 30; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 60 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final K key30; + private final V val30; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap30To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final K key30, final V val30, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.key30 = key30; + this.val30 = val30; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap7To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap7To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap7To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap7To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap24To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap24To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap6To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap6To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap1To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap1To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap2To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap2To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap22To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap22To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap6To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap6To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap16To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap16To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap7To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap7To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap15To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap15To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap3To28Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 28; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 27 * addressSize; + + static final long nodeBase = rareBase + 28 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + + protected SetMultimap3To28Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + } + } + + protected static class SetMultimap0To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap0To6Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap16To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap16To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap24To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap24To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap1To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap1To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap20To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap20To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap8To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap8To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap4To42Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 42; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 41 * addressSize; + + static final long nodeBase = rareBase + 42 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + + protected SetMultimap4To42Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + } + } + + protected static class SetMultimap3To52Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 52; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 51 * addressSize; + + static final long nodeBase = rareBase + 52 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + + protected SetMultimap3To52Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + } + } + + protected static class SetMultimap12To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap12To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap22To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap22To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap17To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap17To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap15To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap15To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap25To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap25To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap2To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap2To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap4To53Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 53; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 52 * addressSize; + + static final long nodeBase = rareBase + 53 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + + protected SetMultimap4To53Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + } + } + + protected static class SetMultimap0To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap0To32Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap29To6Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 6; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 5 * addressSize; + + static final long nodeBase = rareBase + 6 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + + protected SetMultimap29To6Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + } + } + + protected static class SetMultimap6To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap6To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap27To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + + protected SetMultimap27To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap8To35Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 35; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 34 * addressSize; + + static final long nodeBase = rareBase + 35 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + + protected SetMultimap8To35Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + } + } + + protected static class SetMultimap5To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap5To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap14To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap14To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap15To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap15To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap3To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap3To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap10To32Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 32; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 31 * addressSize; + + static final long nodeBase = rareBase + 32 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + + protected SetMultimap10To32Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + } + } + + protected static class SetMultimap5To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap5To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap5To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap5To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap7To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap7To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap9To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap9To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap4To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap4To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap9To46Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 46; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 45 * addressSize; + + static final long nodeBase = rareBase + 46 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + + protected SetMultimap9To46Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + } + } + + protected static class SetMultimap11To14Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 14; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 13 * addressSize; + + static final long nodeBase = rareBase + 14 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + + protected SetMultimap11To14Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + } + } + + protected static class SetMultimap1To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap1To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + + protected static class SetMultimap1To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap1To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap9To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap9To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap16To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap16To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap3To58Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 58; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 57 * addressSize; + + static final long nodeBase = rareBase + 58 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + + protected SetMultimap3To58Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + } + } + + protected static class SetMultimap0To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap0To17Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap4To12Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 12; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 11 * addressSize; + + static final long nodeBase = rareBase + 12 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + + protected SetMultimap4To12Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + } + } + + protected static class SetMultimap11To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap11To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap21To3Node extends CompactSetMultimapNode { + + static final int payloadArity = 21; + + static final int untypedSlotArity = 3; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 42 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 2 * addressSize; + + static final long nodeBase = rareBase + 3 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final Object slot0; + private final Object slot1; + private final Object slot2; + + protected SetMultimap21To3Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final Object slot0, final Object slot1, final Object slot2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + } + } + + protected static class SetMultimap10To17Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 17; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 16 * addressSize; + + static final long nodeBase = rareBase + 17 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + + protected SetMultimap10To17Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + } + } + + protected static class SetMultimap24To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap24To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap25To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 25; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 50 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap25To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap5To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap5To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap12To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap12To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap2To18Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 18; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 17 * addressSize; + + static final long nodeBase = rareBase + 18 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + + protected SetMultimap2To18Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + } + } + + protected static class SetMultimap27To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 27; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 54 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap27To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap13To20Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 20; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 19 * addressSize; + + static final long nodeBase = rareBase + 20 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + + protected SetMultimap13To20Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + } + } + + protected static class SetMultimap5To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + + protected SetMultimap5To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap11To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap11To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap10To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap10To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap20To23Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 23; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 22 * addressSize; + + static final long nodeBase = rareBase + 23 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + + protected SetMultimap20To23Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + } + } + + protected static class SetMultimap8To7Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 7; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 6 * addressSize; + + static final long nodeBase = rareBase + 7 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + + protected SetMultimap8To7Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + } + } + + protected static class SetMultimap19To1Node extends CompactSetMultimapNode { + + static final int payloadArity = 19; + + static final int untypedSlotArity = 1; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 38 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase + 1 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final Object slot0; + + protected SetMultimap19To1Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final Object slot0) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.slot0 = slot0; + } + } + + protected static class SetMultimap1To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + + protected SetMultimap1To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap3To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap3To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap3To55Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 55; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 54 * addressSize; + + static final long nodeBase = rareBase + 55 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + + protected SetMultimap3To55Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + } + } + + protected static class SetMultimap3To40Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 40; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 39 * addressSize; + + static final long nodeBase = rareBase + 40 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + + protected SetMultimap3To40Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + } + } + + protected static class SetMultimap2To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + + protected SetMultimap2To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + } + } + + protected static class SetMultimap14To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap14To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap0To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap0To4Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap8To33Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 33; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 32 * addressSize; + + static final long nodeBase = rareBase + 33 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + + protected SetMultimap8To33Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + } + } + + protected static class SetMultimap7To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap7To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap17To13Node extends CompactSetMultimapNode { + + static final int payloadArity = 17; + + static final int untypedSlotArity = 13; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 34 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 12 * addressSize; + + static final long nodeBase = rareBase + 13 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + + protected SetMultimap17To13Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + } + } + + protected static class SetMultimap9To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap9To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap1To51Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 51; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 50 * addressSize; + + static final long nodeBase = rareBase + 51 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + + protected SetMultimap1To51Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + } + } + + protected static class SetMultimap6To36Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 36; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 35 * addressSize; + + static final long nodeBase = rareBase + 36 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + + protected SetMultimap6To36Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + } + } + + protected static class SetMultimap15To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap15To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap4To54Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 54; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 53 * addressSize; + + static final long nodeBase = rareBase + 54 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + + protected SetMultimap4To54Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44, final Object slot45, final Object slot46, + final Object slot47, final Object slot48, final Object slot49, final Object slot50, + final Object slot51, final Object slot52, final Object slot53) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + } + } + + protected static class SetMultimap6To25Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 25; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 24 * addressSize; + + static final long nodeBase = rareBase + 25 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + + protected SetMultimap6To25Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + } + } + + protected static class SetMultimap2To47Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 47; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 46 * addressSize; + + static final long nodeBase = rareBase + 47 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + + protected SetMultimap2To47Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + } + } + + protected static class SetMultimap22To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap22To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap13To9Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 9; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 8 * addressSize; + + static final long nodeBase = rareBase + 9 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + + protected SetMultimap13To9Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + } + } + + protected static class SetMultimap9To21Node extends CompactSetMultimapNode { + + static final int payloadArity = 9; + + static final int untypedSlotArity = 21; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 18 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 20 * addressSize; + + static final long nodeBase = rareBase + 21 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + + protected SetMultimap9To21Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + } + } + + protected static class SetMultimap16To19Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 19; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 18 * addressSize; + + static final long nodeBase = rareBase + 19 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + + protected SetMultimap16To19Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + } + } + + protected static class SetMultimap8To5Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 5; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 4 * addressSize; + + static final long nodeBase = rareBase + 5 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + + protected SetMultimap8To5Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + } + } + + protected static class SetMultimap0To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap0To11Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap1To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 1; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 2 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap1To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37, final Object slot38, + final Object slot39, final Object slot40, final Object slot41, final Object slot42, + final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap11To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap11To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap5To45Node extends CompactSetMultimapNode { + + static final int payloadArity = 5; + + static final int untypedSlotArity = 45; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 10 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 44 * addressSize; + + static final long nodeBase = rareBase + 45 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + + protected SetMultimap5To45Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + } + } + + protected static class SetMultimap18To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 18; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 36 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap18To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap3To41Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 41; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 40 * addressSize; + + static final long nodeBase = rareBase + 41 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + + protected SetMultimap3To41Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + } + } + + protected static class SetMultimap10To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap10To34Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap10To11Node extends CompactSetMultimapNode { + + static final int payloadArity = 10; + + static final int untypedSlotArity = 11; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 20 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 10 * addressSize; + + static final long nodeBase = rareBase + 11 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + + protected SetMultimap10To11Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + } + } + + protected static class SetMultimap26To0Node extends CompactSetMultimapNode { + + static final int payloadArity = 26; + + static final int untypedSlotArity = 0; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 52 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase; + + static final long nodeBase = rareBase; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + + protected SetMultimap26To0Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + } + } + + protected static class SetMultimap6To22Node extends CompactSetMultimapNode { + + static final int payloadArity = 6; + + static final int untypedSlotArity = 22; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 12 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 21 * addressSize; + + static final long nodeBase = rareBase + 22 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + + protected SetMultimap6To22Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + } + } + + protected static class SetMultimap24To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 24; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 48 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap24To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap7To2Node extends CompactSetMultimapNode { + + static final int payloadArity = 7; + + static final int untypedSlotArity = 2; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 14 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 1 * addressSize; + + static final long nodeBase = rareBase + 2 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final Object slot0; + private final Object slot1; + + protected SetMultimap7To2Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final Object slot0, final Object slot1) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.slot0 = slot0; + this.slot1 = slot1; + } + } + + protected static class SetMultimap22To16Node extends CompactSetMultimapNode { + + static final int payloadArity = 22; + + static final int untypedSlotArity = 16; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 44 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 15 * addressSize; + + static final long nodeBase = rareBase + 16 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + + protected SetMultimap22To16Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + } + } + + protected static class SetMultimap16To26Node extends CompactSetMultimapNode { + + static final int payloadArity = 16; + + static final int untypedSlotArity = 26; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 32 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 25 * addressSize; + + static final long nodeBase = rareBase + 26 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + + protected SetMultimap16To26Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + } + } + + protected static class SetMultimap15To10Node extends CompactSetMultimapNode { + + static final int payloadArity = 15; + + static final int untypedSlotArity = 10; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 30 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 9 * addressSize; + + static final long nodeBase = rareBase + 10 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + + protected SetMultimap15To10Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + } + } + + protected static class SetMultimap4To30Node extends CompactSetMultimapNode { + + static final int payloadArity = 4; + + static final int untypedSlotArity = 30; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 8 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 29 * addressSize; + + static final long nodeBase = rareBase + 30 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + + protected SetMultimap4To30Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + } + } + + protected static class SetMultimap29To4Node extends CompactSetMultimapNode { + + static final int payloadArity = 29; + + static final int untypedSlotArity = 4; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 58 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 3 * addressSize; + + static final long nodeBase = rareBase + 4 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final K key21; + private final V val21; + private final K key22; + private final V val22; + private final K key23; + private final V val23; + private final K key24; + private final V val24; + private final K key25; + private final V val25; + private final K key26; + private final V val26; + private final K key27; + private final V val27; + private final K key28; + private final V val28; + private final K key29; + private final V val29; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + + protected SetMultimap29To4Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final K key21, final V val21, + final K key22, final V val22, final K key23, final V val23, final K key24, final V val24, + final K key25, final V val25, final K key26, final V val26, final K key27, final V val27, + final K key28, final V val28, final K key29, final V val29, final Object slot0, + final Object slot1, final Object slot2, final Object slot3) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.key21 = key21; + this.val21 = val21; + this.key22 = key22; + this.val22 = val22; + this.key23 = key23; + this.val23 = val23; + this.key24 = key24; + this.val24 = val24; + this.key25 = key25; + this.val25 = val25; + this.key26 = key26; + this.val26 = val26; + this.key27 = key27; + this.val27 = val27; + this.key28 = key28; + this.val28 = val28; + this.key29 = key29; + this.val29 = val29; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + } + } + + protected static class SetMultimap14To29Node extends CompactSetMultimapNode { + + static final int payloadArity = 14; + + static final int untypedSlotArity = 29; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 28 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 28 * addressSize; + + static final long nodeBase = rareBase + 29 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + + protected SetMultimap14To29Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + } + } + + protected static class SetMultimap0To34Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 34; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 33 * addressSize; + + static final long nodeBase = rareBase + 34 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + + protected SetMultimap0To34Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + } + } + + protected static class SetMultimap8To8Node extends CompactSetMultimapNode { + + static final int payloadArity = 8; + + static final int untypedSlotArity = 8; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 16 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 7 * addressSize; + + static final long nodeBase = rareBase + 8 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + + protected SetMultimap8To8Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + } + } + + protected static class SetMultimap3To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 3; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 6 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap3To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap11To31Node extends CompactSetMultimapNode { + + static final int payloadArity = 11; + + static final int untypedSlotArity = 31; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 22 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 30 * addressSize; + + static final long nodeBase = rareBase + 31 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + + protected SetMultimap11To31Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + } + } + + protected static class SetMultimap12To15Node extends CompactSetMultimapNode { + + static final int payloadArity = 12; + + static final int untypedSlotArity = 15; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 24 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 14 * addressSize; + + static final long nodeBase = rareBase + 15 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + + protected SetMultimap12To15Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + } + } + + protected static class SetMultimap2To56Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 56; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 55 * addressSize; + + static final long nodeBase = rareBase + 56 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + + protected SetMultimap2To56Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48, + final Object slot49, final Object slot50, final Object slot51, final Object slot52, + final Object slot53, final Object slot54, final Object slot55) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + } + } + + protected static class SetMultimap0To61Node extends CompactSetMultimapNode { + + static final int payloadArity = 0; + + static final int untypedSlotArity = 61; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 0 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 60 * addressSize; + + static final long nodeBase = rareBase + 61 * addressSize; + + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + private final Object slot49; + private final Object slot50; + private final Object slot51; + private final Object slot52; + private final Object slot53; + private final Object slot54; + private final Object slot55; + private final Object slot56; + private final Object slot57; + private final Object slot58; + private final Object slot59; + private final Object slot60; + + protected SetMultimap0To61Node(final AtomicReference mutator, final long bitmap, + final Object slot0, final Object slot1, final Object slot2, final Object slot3, + final Object slot4, final Object slot5, final Object slot6, final Object slot7, + final Object slot8, final Object slot9, final Object slot10, final Object slot11, + final Object slot12, final Object slot13, final Object slot14, final Object slot15, + final Object slot16, final Object slot17, final Object slot18, final Object slot19, + final Object slot20, final Object slot21, final Object slot22, final Object slot23, + final Object slot24, final Object slot25, final Object slot26, final Object slot27, + final Object slot28, final Object slot29, final Object slot30, final Object slot31, + final Object slot32, final Object slot33, final Object slot34, final Object slot35, + final Object slot36, final Object slot37, final Object slot38, final Object slot39, + final Object slot40, final Object slot41, final Object slot42, final Object slot43, + final Object slot44, final Object slot45, final Object slot46, final Object slot47, + final Object slot48, final Object slot49, final Object slot50, final Object slot51, + final Object slot52, final Object slot53, final Object slot54, final Object slot55, + final Object slot56, final Object slot57, final Object slot58, final Object slot59, + final Object slot60) { + super(mutator, bitmap); + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + this.slot49 = slot49; + this.slot50 = slot50; + this.slot51 = slot51; + this.slot52 = slot52; + this.slot53 = slot53; + this.slot54 = slot54; + this.slot55 = slot55; + this.slot56 = slot56; + this.slot57 = slot57; + this.slot58 = slot58; + this.slot59 = slot59; + this.slot60 = slot60; + } + } + + protected static class SetMultimap2To49Node extends CompactSetMultimapNode { + + static final int payloadArity = 2; + + static final int untypedSlotArity = 49; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 4 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 48 * addressSize; + + static final long nodeBase = rareBase + 49 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + private final Object slot38; + private final Object slot39; + private final Object slot40; + private final Object slot41; + private final Object slot42; + private final Object slot43; + private final Object slot44; + private final Object slot45; + private final Object slot46; + private final Object slot47; + private final Object slot48; + + protected SetMultimap2To49Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23, final Object slot24, + final Object slot25, final Object slot26, final Object slot27, final Object slot28, + final Object slot29, final Object slot30, final Object slot31, final Object slot32, + final Object slot33, final Object slot34, final Object slot35, final Object slot36, + final Object slot37, final Object slot38, final Object slot39, final Object slot40, + final Object slot41, final Object slot42, final Object slot43, final Object slot44, + final Object slot45, final Object slot46, final Object slot47, final Object slot48) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + this.slot38 = slot38; + this.slot39 = slot39; + this.slot40 = slot40; + this.slot41 = slot41; + this.slot42 = slot42; + this.slot43 = slot43; + this.slot44 = slot44; + this.slot45 = slot45; + this.slot46 = slot46; + this.slot47 = slot47; + this.slot48 = slot48; + } + } + + protected static class SetMultimap20To24Node extends CompactSetMultimapNode { + + static final int payloadArity = 20; + + static final int untypedSlotArity = 24; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 40 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 23 * addressSize; + + static final long nodeBase = rareBase + 24 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + private final K key17; + private final V val17; + private final K key18; + private final V val18; + private final K key19; + private final V val19; + private final K key20; + private final V val20; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + + protected SetMultimap20To24Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final K key14, final V val14, final K key15, final V val15, + final K key16, final V val16, final K key17, final V val17, final K key18, final V val18, + final K key19, final V val19, final K key20, final V val20, final Object slot0, + final Object slot1, final Object slot2, final Object slot3, final Object slot4, + final Object slot5, final Object slot6, final Object slot7, final Object slot8, + final Object slot9, final Object slot10, final Object slot11, final Object slot12, + final Object slot13, final Object slot14, final Object slot15, final Object slot16, + final Object slot17, final Object slot18, final Object slot19, final Object slot20, + final Object slot21, final Object slot22, final Object slot23) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + this.key17 = key17; + this.val17 = val17; + this.key18 = key18; + this.val18 = val18; + this.key19 = key19; + this.val19 = val19; + this.key20 = key20; + this.val20 = val20; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + } + } + + protected static class SetMultimap13To27Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 27; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 26 * addressSize; + + static final long nodeBase = rareBase + 27 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + + protected SetMultimap13To27Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + } + } + + protected static class SetMultimap13To38Node extends CompactSetMultimapNode { + + static final int payloadArity = 13; + + static final int untypedSlotArity = 38; + + static final int slotArity = payloadArity * TUPLE_LENGTH + untypedSlotArity; + + static final long rareBase = arrayBase + 26 * addressSize /* TODO: sizeOf(ts.ds) */; + + static final long arrayOffsetLast = rareBase + 37 * addressSize; + + static final long nodeBase = rareBase + 38 * addressSize; + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final Object slot0; + private final Object slot1; + private final Object slot2; + private final Object slot3; + private final Object slot4; + private final Object slot5; + private final Object slot6; + private final Object slot7; + private final Object slot8; + private final Object slot9; + private final Object slot10; + private final Object slot11; + private final Object slot12; + private final Object slot13; + private final Object slot14; + private final Object slot15; + private final Object slot16; + private final Object slot17; + private final Object slot18; + private final Object slot19; + private final Object slot20; + private final Object slot21; + private final Object slot22; + private final Object slot23; + private final Object slot24; + private final Object slot25; + private final Object slot26; + private final Object slot27; + private final Object slot28; + private final Object slot29; + private final Object slot30; + private final Object slot31; + private final Object slot32; + private final Object slot33; + private final Object slot34; + private final Object slot35; + private final Object slot36; + private final Object slot37; + + protected SetMultimap13To38Node(final AtomicReference mutator, final long bitmap, + final K key1, final V val1, final K key2, final V val2, final K key3, final V val3, + final K key4, final V val4, final K key5, final V val5, final K key6, final V val6, + final K key7, final V val7, final K key8, final V val8, final K key9, final V val9, + final K key10, final V val10, final K key11, final V val11, final K key12, final V val12, + final K key13, final V val13, final Object slot0, final Object slot1, final Object slot2, + final Object slot3, final Object slot4, final Object slot5, final Object slot6, + final Object slot7, final Object slot8, final Object slot9, final Object slot10, + final Object slot11, final Object slot12, final Object slot13, final Object slot14, + final Object slot15, final Object slot16, final Object slot17, final Object slot18, + final Object slot19, final Object slot20, final Object slot21, final Object slot22, + final Object slot23, final Object slot24, final Object slot25, final Object slot26, + final Object slot27, final Object slot28, final Object slot29, final Object slot30, + final Object slot31, final Object slot32, final Object slot33, final Object slot34, + final Object slot35, final Object slot36, final Object slot37) { + super(mutator, bitmap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.slot0 = slot0; + this.slot1 = slot1; + this.slot2 = slot2; + this.slot3 = slot3; + this.slot4 = slot4; + this.slot5 = slot5; + this.slot6 = slot6; + this.slot7 = slot7; + this.slot8 = slot8; + this.slot9 = slot9; + this.slot10 = slot10; + this.slot11 = slot11; + this.slot12 = slot12; + this.slot13 = slot13; + this.slot14 = slot14; + this.slot15 = slot15; + this.slot16 = slot16; + this.slot17 = slot17; + this.slot18 = slot18; + this.slot19 = slot19; + this.slot20 = slot20; + this.slot21 = slot21; + this.slot22 = slot22; + this.slot23 = slot23; + this.slot24 = slot24; + this.slot25 = slot25; + this.slot26 = slot26; + this.slot27 = slot27; + this.slot28 = slot28; + this.slot29 = slot29; + this.slot30 = slot30; + this.slot31 = slot31; + this.slot32 = slot32; + this.slot33 = slot33; + this.slot34 = slot34; + this.slot35 = slot35; + this.slot36 = slot36; + this.slot37 = slot37; + } + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specialized.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specialized.java new file mode 100644 index 0000000..92e4a4b --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specialized.java @@ -0,0 +1,4519 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.multimap; + +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Deque; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import io.usethesource.capsule.SetMultimap; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations.SetMultimap0To0Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations.SetMultimap0To1Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations.SetMultimap0To2Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations.SetMultimap0To4Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations.SetMultimap1To0Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations.SetMultimap1To2Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations.SetMultimap2To0Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized.EitherSingletonOrCollection.Type; +import io.usethesource.capsule.util.EqualityComparator; +import io.usethesource.capsule.util.RangecopyUtils; +import io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap; + +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_DATA_COLLECTION; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_DATA_SINGLETON; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_EMPTY; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_NODE; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setBitPattern; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setOf; +import static io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized.EitherSingletonOrCollection.Type.COLLECTION; +import static io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized.EitherSingletonOrCollection.Type.SINGLETON; +import static io.usethesource.capsule.util.BitmapUtils.filter; +import static io.usethesource.capsule.util.BitmapUtils.index; +import static io.usethesource.capsule.util.DataLayoutHelper.addressSize; +import static io.usethesource.capsule.util.DataLayoutHelper.arrayOffsets; +import static io.usethesource.capsule.util.DataLayoutHelper.fieldOffset; +import static io.usethesource.capsule.util.DataLayoutHelper.unsafe; +import static io.usethesource.capsule.util.RangecopyUtils._do_rangecompareObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.getFromObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.getFromObjectRegionAndCast; +import static io.usethesource.capsule.util.RangecopyUtils.rangecopyObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.setInObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.setInObjectRegionVarArgs; +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +public class TrieSetMultimap_HHAMT_Specialized implements SetMultimap.Immutable { + + private final EqualityComparator cmp; + + protected static final CompactSetMultimapNode EMPTY_NODE = new SetMultimap0To0Node<>(null, 0L); + + private static final TrieSetMultimap_HHAMT_Specialized EMPTY_SETMULTIMAP = + new TrieSetMultimap_HHAMT_Specialized(EqualityComparator.EQUALS, EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractSetMultimapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieSetMultimap_HHAMT_Specialized(EqualityComparator cmp, + AbstractSetMultimapNode rootNode, int hashCode, int cachedSize) { + this.cmp = cmp; + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final SetMultimap.Immutable of() { + return TrieSetMultimap_HHAMT_Specialized.EMPTY_SETMULTIMAP; + } + + public static final SetMultimap.Immutable of(EqualityComparator cmp) { + // TODO: unify with `of()` + return new TrieSetMultimap_HHAMT_Specialized(cmp, EMPTY_NODE, 0, 0); + } + + public static final SetMultimap.Immutable of(K key, V... values) { + SetMultimap.Immutable result = TrieSetMultimap_HHAMT_Specialized.EMPTY_SETMULTIMAP; + + for (V value : values) { + result = result.__insert(key, value); + } + + return result; + } + + public static final SetMultimap.Transient transientOf() { + return TrieSetMultimap_HHAMT_Specialized.EMPTY_SETMULTIMAP.asTransient(); + } + + public static final SetMultimap.Transient transientOf(K key, V... values) { + final SetMultimap.Transient result = + TrieSetMultimap_HHAMT_Specialized.EMPTY_SETMULTIMAP.asTransient(); + + for (V value : values) { + result.__insert(key, value); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + // int hash = 0; + // int size = 0; + // + // for (Iterator> it = entryIterator(); it.hasNext();) { + // final Map.Entry entry = it.next(); + // final K key = entry.getKey(); + // final V val = entry.getValue(); + // + // hash += key.hashCode() ^ val.hashCode(); + // size += 1; + // } + // + // return hash == targetHash && size == targetSize; + + int size = 0; + + for (Iterator it = keyIterator(); it.hasNext(); ) { + final K key = it.next(); + size += 1; + } + + if (size != targetSize) { + System.out.println(String.format("size (%d) != targetSize (%d)", size, targetSize)); + } + + return size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.equals(iterator.next(), o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + return rootNode.containsTuple(key, val, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public SetMultimap.Immutable __put(K key, V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieSetMultimap_HHAMT_Specialized(cmp, newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + final int valHashNew = val.hashCode(); + + return new TrieSetMultimap_HHAMT_Specialized(cmp, newRootNode, + hashCode + ((keyHash ^ valHashNew)) - sumOfReplacedHashes, + cachedSize - details.getReplacedCollection().size() + 1); + } + } + + final int valHash = val.hashCode(); + return new TrieSetMultimap_HHAMT_Specialized(cmp, newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable __insert(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + final int valHash = val.hashCode(); + return new TrieSetMultimap_HHAMT_Specialized(cmp, newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable union( + final SetMultimap setMultimap) { + final SetMultimap.Transient tmpTransient = this.asTransient(); + tmpTransient.union(setMultimap); + return tmpTransient.freeze(); + } + + @Override + public SetMultimap.Immutable __remove(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap_HHAMT_Specialized(cmp, newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable __remove(K key) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removedAll(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap_HHAMT_Specialized(cmp, newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + return new TrieSetMultimap_HHAMT_Specialized(cmp, newRootNode, + hashCode - sumOfReplacedHashes, cachedSize - details.getReplacedCollection().size()); + } + } + + return this; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new SetMultimapKeyIteratorOffsetHistogram<>(rootNode); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(Set::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + // return new SetMultimapTupleIterator<>(rootNode, AbstractSpecialisedImmutableMap::entryOf); + + return new SetMultimapFlattenedTupleIteratorOffsetHistogram<>(rootNode); + // return new FlatteningIterator<>(nativeEntryIterator()); + } + + @Override + public Iterator> nativeEntryIterator() { + return new SetMultimapNativeTupleIteratorOffsetHistogram<>(rootNode); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new SetMultimapTupleIterator<>(rootNode, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieSetMultimap_HHAMT_Specialized.this.keyIterator(); + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT_Specialized.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT_Specialized.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieSetMultimap_HHAMT_Specialized.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieSetMultimap_HHAMT_Specialized.this.valueIterator(); + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT_Specialized.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT_Specialized.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TrieSetMultimap_HHAMT_Specialized.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT_Specialized.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT_Specialized.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieSetMultimap_HHAMT_Specialized.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieSetMultimap_HHAMT_Specialized) { + TrieSetMultimap_HHAMT_Specialized that = + (TrieSetMultimap_HHAMT_Specialized) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + final io.usethesource.capsule.Set.Immutable valColl = (io.usethesource.capsule.Set.Immutable) entry + .getValue(); + + if (!cmp.equals(result.get(), valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public SetMultimap.Transient asTransient() { + return new TransientTrieSetMultimap_BleedingEdge(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractSetMultimapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieSetMultimap_BleedingEdgeNodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + static abstract class EitherSingletonOrCollection { + + public enum Type { + SINGLETON, COLLECTION + } + + public static final EitherSingletonOrCollection of(T value) { + return new SomeSingleton<>(value); + } + + public static final EitherSingletonOrCollection of( + io.usethesource.capsule.Set.Immutable value) { + return new SomeCollection<>(value); + } + + abstract boolean isType(Type type); + + abstract T getSingleton(); + + abstract io.usethesource.capsule.Set.Immutable getCollection(); + } + + static final class SomeSingleton extends EitherSingletonOrCollection { + + private final T value; + + private SomeSingleton(T value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.SINGLETON; + } + + @Override + T getSingleton() { + return value; + } + + @Override + io.usethesource.capsule.Set.Immutable getCollection() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.COLLECTION, Type.SINGLETON)); + } + } + + static final class SomeCollection extends EitherSingletonOrCollection { + + private final io.usethesource.capsule.Set.Immutable value; + + private SomeCollection(io.usethesource.capsule.Set.Immutable value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.COLLECTION; + } + + @Override + T getSingleton() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.SINGLETON, Type.COLLECTION)); + } + + @Override + io.usethesource.capsule.Set.Immutable getCollection() { + return value; + } + } + + static final class SetMultimapResult { + + private V replacedValue; + private io.usethesource.capsule.Set.Immutable replacedValueCollection; + private EitherSingletonOrCollection.Type replacedType; + + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(V replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + this.replacedType = SINGLETON; + } + + public void updated(io.usethesource.capsule.Set.Immutable replacedValueCollection) { + this.replacedValueCollection = replacedValueCollection; + this.isModified = true; + this.isReplaced = true; + this.replacedType = COLLECTION; + } + + // update: neither element, nor element count changed + public static SetMultimapResult unchanged() { + return new SetMultimapResult<>(); + } + + private SetMultimapResult() { + } + + public boolean isModified() { + return isModified; + } + + public EitherSingletonOrCollection.Type getType() { + return replacedType; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public V getReplacedValue() { + assert getType() == SINGLETON; + return replacedValue; + } + + public io.usethesource.capsule.Set.Immutable getReplacedCollection() { + assert getType() == COLLECTION; + return replacedValueCollection; + } + } + + protected static interface INode { + + } + + protected static abstract class AbstractSetMultimapNode implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract boolean containsTuple(final K key, final V val, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract Optional> findByKey(final K key, + final int keyHash, final int shift, + EqualityComparator cmp); + + abstract CompactSetMultimapNode inserted(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode updated(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode removed(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode removedAll(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractSetMultimapNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractSetMultimapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractSetMultimapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract int emptyArity(); + + // @Deprecated // split data / coll arity + abstract boolean hasPayload(); + + // + // @Deprecated // split data / coll arity + abstract int payloadArity(); + + abstract boolean hasPayload(EitherSingletonOrCollection.Type type); + + // abstract int payloadArity(); + + abstract int payloadArity(EitherSingletonOrCollection.Type type); + + abstract K getSingletonKey(final int index); + + abstract V getSingletonValue(final int index); + + abstract K getCollectionKey(final int index); + + abstract io.usethesource.capsule.Set.Immutable getCollectionValue(final int index); + + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + abstract int arity(); + + abstract int arity(final int pattern); + + abstract int[] arities(); + + abstract long[] offsetRangeTuples(); + + abstract int[] slotRangeTuples(); + + int size() { + final Iterator it = new SetMultimapKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactSetMultimapNode + extends AbstractSetMultimapNode { + + private long bitmap; + + // private int cachedSlotArity; + // private int cachedNodeArity; + // private int cachedEmptyArity; + + @Deprecated + final void initializeLazyFields() { + // NOTE: temporariliy used to test caching of attributes; will be removed soon again + + // cachedSlotArity = (int) staticSlotArity(); + // cachedNodeArity = (int) Long.bitCount(filter(bitmap, PATTERN_NODE)); + // cachedEmptyArity = (int) Long.bitCount(filter(bitmap, PATTERN_EMPTY)); + } + + CompactSetMultimapNode(final AtomicReference mutator, final long bitmap) { + this.bitmap = bitmap; + initializeLazyFields(); + } + + final long bitmap() { + return bitmap; + } + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + static final int doubledMask(int keyHash, int shift) { + final int mask = mask(keyHash, shift); + return mask << 1; + } + + static final long doubledBitpos(final int doubledMask) { + return 1L << doubledMask; + } + + static final int pattern(long bitmap, int doubledMask) { + return (int) ((bitmap >>> doubledMask) & 0b11); + } + + static final long initializeArrayBase() { + try { + // assuems that both are of type Object and next to each other in memory + return DataLayoutHelper.arrayOffsets[0]; + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + static final long arrayBase = initializeArrayBase(); + + // static final Class[][] initializeSpecializationsByContentAndNodes() { + // Class[][] next = new Class[33][65]; + // + // try { + // for (int m = 0; m <= 32; m++) { + // for (int n = 0; n <= 64; n++) { + // int mNext = m; + // int nNext = n; + // + // // TODO: last expression is not properly generated yet and maybe incorrect + // if (mNext < 0 || mNext > 32 || nNext < 0 || nNext > 64 + // || Math.ceil(nNext / 2.0) + mNext > 32) { + // next[m][n] = null; + // } else { + // next[m][n] = Class.forName(String.format( + // "io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations$SetMultimap%dTo%dNode", + // mNext, nNext)); + // } + // } + // } + // } catch (ClassNotFoundException e) { + // throw new RuntimeException(e); + // } + // + // return next; + // } + // + // static final Class[][] specializationsByContentAndNodes = + // initializeSpecializationsByContentAndNodes(); + + static final Class[] initializeSpecializationsByContentAndNodes() { + Class[] next = new Class[33 * 65]; + + try { + for (int m = 0; m <= 32; m++) { + for (int n = 0; n <= 64; n++) { + int mNext = m; + int nNext = n; + + // TODO: last expression is not properly generated yet and maybe incorrect + if (mNext < 0 || mNext > 32 || nNext < 0 || nNext > 64 + || Math.ceil(nNext / 2.0) + mNext > 32) { + next[65 * m + n] = null; + } else { + next[65 * m + n] = Class.forName(String.format( + "io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations$SetMultimap%dTo%dNode", + mNext, nNext)); + } + } + } + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } + + return next; + } + + // @java.lang.invoke.Stable + static final Class[] specializationsByContentAndNodes = + initializeSpecializationsByContentAndNodes(); + + static final T allocateHeapRegion(final Class[] lookupTable, final int dim1, + final int dim2) { + final Class clazz = lookupTable[65 * dim1 + dim2]; + return RangecopyUtils.allocateHeapRegion(clazz); + } + + // static final byte[] initializeMetadataByContentAndNodes() { + // byte[] next = new byte[33 * 65 * 4]; + // + // try { + // for (int m = 0; m <= 32; m++) { + // for (int n = 0; n <= 64; n++) { + // int mNext = m; + // int nNext = n; + // + // // TODO: last expression is not properly generated yet and maybe incorrect + // if (mNext < 0 || mNext > 32 || nNext < 0 || nNext > 64 + // || Math.ceil(nNext / 2.0) + mNext > 32) { + //// int section = (65 * m + n) * 4; + //// next[65 * m + n] = 0; + // } else { + // Class clazz = Class.forName(String.format( + // "io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations$SetMultimap%dTo%dNode", + // mNext, nNext)); + // + // int section = (65 * m + n) * 4; + // next[section + 0] = (byte) unsafe.getLong(clazz, globalRareBaseOffset); + // next[section + 1] = (byte) unsafe.getInt(clazz, globalPayloadArityOffset); + // next[section + 2] = (byte) unsafe.getInt(clazz, globalUntypedSlotArityOffset); + // next[section + 3] = (byte) unsafe.getInt(clazz, globalSlotArityOffset); + // + // if (next[section + 0] < 0) + // System.out.println(next[section + 0]); + // } + // } + // } + // } catch (ClassNotFoundException e) { + // throw new RuntimeException(e); + // } + // + // return next; + // } + // + // static final byte[] metadataByContentAndNodes = + // initializeMetadataByContentAndNodes(); + + static long globalRawMap1Offset = fieldOffset(SetMultimap0To2Node.class, "rawMap1"); + + static long globalRawMap2Offset = fieldOffset(SetMultimap0To2Node.class, "rawMap2"); + + static long globalArrayOffsetsOffset = fieldOffset(SetMultimap0To2Node.class, "arrayOffsets"); + + static long globalNodeArityOffset = fieldOffset(SetMultimap0To2Node.class, "nodeArity"); + + static long globalPayloadArityOffset = fieldOffset(SetMultimap0To2Node.class, "payloadArity"); + + static long globalSlotArityOffset = fieldOffset(SetMultimap0To2Node.class, "slotArity"); + + static long globalUntypedSlotArityOffset = + fieldOffset(SetMultimap0To2Node.class, "untypedSlotArity"); + + static long globalRareBaseOffset = fieldOffset(SetMultimap0To2Node.class, "rareBase"); + + static long globalArrayOffsetLastOffset = + fieldOffset(SetMultimap0To2Node.class, "arrayOffsetLast"); + + static long globalNodeBaseOffset = fieldOffset(SetMultimap0To2Node.class, "nodeBase"); + + private final long staticRareBase() { + return unsafe.getLong(this.getClass(), globalRareBaseOffset); + } + + private final long staticNodeBase() { + return unsafe.getLong(this.getClass(), globalNodeBaseOffset); + } + + private final int staticSlotArity() { + return unsafe.getInt(this.getClass(), globalSlotArityOffset); + } + + private final int staticUntypedSlotArity() { + return unsafe.getInt(this.getClass(), globalUntypedSlotArityOffset); + } + + private final int staticPayloadArity() { + return unsafe.getInt(this.getClass(), globalPayloadArityOffset); + } + + // @Deprecated + // abstract int dataMap(); + // + // @Deprecated + // abstract int collMap(); + // + // @Deprecated + // abstract int nodeMap(); + + // NOTE: use 'final' when made collision node indepencent from compact node + @Override + boolean hasPayload() { + return payloadArity() != 0; + } + + // NOTE: use 'final' when made collision node indepencent from compact node + @Override + int payloadArity() { + return 32 - nodeArity() - emptyArity(); + } + + // NOTE: use 'final' when made collision node indepencent from compact node + @Override + boolean hasPayload(EitherSingletonOrCollection.Type type) { + return payloadArity(type) != 0; + } + + // NOTE: use 'final' when made collision node indepencent from compact node + @Override + int payloadArity(EitherSingletonOrCollection.Type type) { + if (type == Type.SINGLETON) { + return arity(bitmap(), PATTERN_DATA_SINGLETON); + } else { + return arity(bitmap(), PATTERN_DATA_COLLECTION); + } + } + + // NOTE: use 'final' when made collision node indepencent from compact node + @Override + K getSingletonKey(final int index) { + return (K) getFromObjectRegion(this, arrayBase, TUPLE_LENGTH * index); + } + + // NOTE: use 'final' when made collision node indepencent from compact node + @Override + V getSingletonValue(final int index) { + return (V) getFromObjectRegion(this, arrayBase, TUPLE_LENGTH * index + 1); + } + + // NOTE: use 'final' when made collision node indepencent from compact node + @Override + K getCollectionKey(final int index) { + return (K) getFromObjectRegion(this, staticRareBase(), TUPLE_LENGTH * index); + } + + // NOTE: use 'final' when made collision node indepencent from compact node + @Override + io.usethesource.capsule.Set.Immutable getCollectionValue(final int index) { + return (io.usethesource.capsule.Set.Immutable) getFromObjectRegion(this, staticRareBase(), + TUPLE_LENGTH * index + 1); + } + + // NOTE: use 'final' when made collision node indepencent from compact node + @Override + boolean hasSlots() { + return slotArity() != 0; + } + + // NOTE: use 'final' when made collision node indepencent from compact node + @Override + int slotArity() { + return staticSlotArity(); + + // return cachedSlotArity; + } + + // NOTE: use 'final' when made collision node indepencent from compact node + @Override + Object getSlot(final int index) { + return getFromObjectRegion(this, arrayBase, index); + } + + @Override + final int emptyArity() { + return Long.bitCount(filter(bitmap, PATTERN_EMPTY)); + // return arity(bitmap, PATTERN_EMPTY); + + // return cachedEmptyArity; + } + + @Deprecated + @Override + int arity() { + // TODO: replace with 32 - arity(emptyMap) + // return arity(bitmap(), PATTERN_DATA_SINGLETON) + arity(bitmap(), PATTERN_DATA_COLLECTION) + + // arity(bitmap(), PATTERN_NODE); + + int[] arities = arities(bitmap()); + return Arrays.stream(arities).skip(1).sum(); + } + + @Override + int arity(final int pattern) { + return arity(bitmap, pattern); + } + + static final int arity(long bitmap, int pattern) { + // if (bitmap == 0) { + // if (pattern == PATTERN_EMPTY) { + // return 32; + // } else { + // return 0; + // } + // } else { + // return Long.bitCount(filter(bitmap, pattern)); + // } + + long filteredBitmap = filter(bitmap, pattern); + + // if (filteredBitmap == 0) { + // if (pattern == PATTERN_EMPTY) { + // return 32; + // } else { + // return 0; + // } + // } + + return Long.bitCount(filteredBitmap); + } + + @Override + public final int[] arities() { + return arities(bitmap); + } + + @Override + public final long[] offsetRangeTuples() { + return offsetRangeTuplesOptimized(bitmap, arrayBase); + } + + @Override + public final int[] slotRangeTuples() { + return slotRangeTuples(bitmap, 0); + } + + static final int[] arities(final long bitmap) { + int[] arities = new int[4]; + + arities[0] = Long.bitCount(filter(bitmap, PATTERN_EMPTY)); + arities[1] = Long.bitCount(filter(bitmap, PATTERN_DATA_SINGLETON)); + arities[2] = Long.bitCount(filter(bitmap, PATTERN_DATA_COLLECTION)); + arities[3] = Long.bitCount(filter(bitmap, PATTERN_NODE)); + + return arities; + } + + // static final int[] lengths() { + // int[] lengths = new int[4]; + // + // lengths[0] = 0; + // lengths[1] = 1; + // lengths[2] = 2; + // lengths[3] = 2; + // + // return lengths; + // } + // + // static final int[] sizes() { + // int[] bytes = new int[4]; + // + // bytes[0] = 0; + // bytes[1] = 1 * (int) addressSize; + // bytes[2] = 2 * (int) addressSize; + // bytes[3] = 2 * (int) addressSize; + // + // return bytes; + // } + // + // static final int[] sizeInBytes() { + // int[] bytes = new int[4]; + // + // bytes[0] = 0; + // bytes[1] = (int) addressSize; + // bytes[2] = (int) addressSize; + // bytes[3] = (int) addressSize; + // + // return bytes; + // } + + // static final int arity(long bitmap, int pattern) { + + final long offsetEnd(final int pattern, final long startOffset) { + return startOffset + lengthInBytes(bitmap, pattern); + } + + final long lengthInBytes(final int pattern) { + return lengthInBytes(bitmap, pattern); + } + + static final long lengthInBytes(final long bitmap, final int pattern) { + final int arity = arity(bitmap, pattern); + final int length; + + switch (pattern) { + case PATTERN_NODE: + length = 1; + break; + case PATTERN_DATA_SINGLETON: + case PATTERN_DATA_COLLECTION: + length = 2; + break; + default: + length = 0; + } + + return arity * length * addressSize; + } + + static final long[] offsetRangeTuples(final long bitmap, final long startOffset) { + long[] offsetRangeTuples = new long[8]; + + offsetRangeTuples[0] = startOffset; + offsetRangeTuples[1] = offsetRangeTuples[0]; + + offsetRangeTuples[2] = offsetRangeTuples[1]; + offsetRangeTuples[3] = + offsetRangeTuples[2] + Long.bitCount(filter(bitmap, PATTERN_NODE)) * addressSize; + + offsetRangeTuples[4] = offsetRangeTuples[3]; + offsetRangeTuples[5] = offsetRangeTuples[4] + + Long.bitCount(filter(bitmap, PATTERN_DATA_SINGLETON)) * addressSize * 2; + + offsetRangeTuples[6] = offsetRangeTuples[5]; + offsetRangeTuples[7] = offsetRangeTuples[6] + + Long.bitCount(filter(bitmap, PATTERN_DATA_COLLECTION)) * addressSize * 2; + + return offsetRangeTuples; + } + + static final long[] offsetRangeTuplesOptimized(final long bitmap, final long startOffset) { + long[] offsetRangeTuples = new long[8]; + + long filteredData = filter(bitmap, PATTERN_DATA_SINGLETON); + long filteredColl = filter(bitmap, PATTERN_DATA_COLLECTION); + long filteredNode = filter(bitmap, PATTERN_NODE); + + // PATTERN_EMPTY + offsetRangeTuples[0] = startOffset; + offsetRangeTuples[1] = offsetRangeTuples[0]; + + // PATTERN_DATA_SINGLETON + offsetRangeTuples[2] = offsetRangeTuples[1]; + offsetRangeTuples[3] = offsetRangeTuples[2] + + ((filteredData == 0L) ? 0L : (Long.bitCount(filteredData) * addressSize * 2)); + + // PATTERN_DATA_COLLECTION + offsetRangeTuples[4] = offsetRangeTuples[3]; + offsetRangeTuples[5] = offsetRangeTuples[4] + + ((filteredColl == 0L) ? 0L : (Long.bitCount(filteredColl) * addressSize * 2)); + + // PATTERN_NODE + offsetRangeTuples[6] = offsetRangeTuples[5]; + offsetRangeTuples[7] = offsetRangeTuples[6] + + ((filteredNode == 0L) ? 0L : (Long.bitCount(filteredNode) * addressSize)); + + return offsetRangeTuples; + } + + static final int[] slotRangeTuples(final long bitmap, final int startSlot) { + int[] offsetRangeTuples = new int[8]; + + offsetRangeTuples[0] = startSlot; + offsetRangeTuples[1] = offsetRangeTuples[0]; + + offsetRangeTuples[2] = offsetRangeTuples[1]; + offsetRangeTuples[3] = + offsetRangeTuples[2] + Long.bitCount(filter(bitmap, PATTERN_DATA_SINGLETON)) * 2; + + offsetRangeTuples[4] = offsetRangeTuples[3]; + offsetRangeTuples[5] = + offsetRangeTuples[4] + Long.bitCount(filter(bitmap, PATTERN_DATA_COLLECTION)) * 2; + + offsetRangeTuples[6] = offsetRangeTuples[5]; + offsetRangeTuples[7] = offsetRangeTuples[6] + Long.bitCount(filter(bitmap, PATTERN_NODE)); + + return offsetRangeTuples; + } + + // static final long[] offsetRangeTuples(final int[] arities, final long startOffset) { + // int[] sizes = sizes(); + // + // long offset = startOffset; + // + // long[] offsetRangeTuples = new long[8]; + // + // offsetRangeTuples[0] = offset; + // offsetRangeTuples[1] = offset; + // + // offsetRangeTuples[4] = offset; + // offsetRangeTuples[5] = offset += sizes[2] * arities[2]; + // + // offsetRangeTuples[6] = offset; + // offsetRangeTuples[7] = offset += sizes[3] * arities[3]; + // + // offsetRangeTuples[2] = offset; + // offsetRangeTuples[3] = offset += sizes[1] * arities[1]; + // + // return offsetRangeTuples; + // } + + static final int[] aritiesSingleLoopOverLong(final long bitmap) { + int[] arities = new int[4]; + + long shiftedBitmap = bitmap; + for (int i = 0; i < 32; i++) { + arities[(int) shiftedBitmap & 0b11]++; + shiftedBitmap = shiftedBitmap >>> 2; + } + + return arities; + } + + static final int[] aritiesDoubleLoopOverInt(final long bitmap) { + int[] arities = new int[4]; + + int segment0 = (int) (bitmap >>> 32); + int segment1 = (int) (bitmap); + + for (int i = 0; i < 16; i++) { + arities[segment0 & 0b11]++; + segment0 = segment0 >>> 2; + } + + for (int i = 0; i < 16; i++) { + arities[segment1 & 0b11]++; + segment1 = segment1 >>> 2; + } + + return arities; + } + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + byte sizePredicate() { + final long bitmap = this.bitmap(); + + int nodeArity = arity(bitmap, PATTERN_NODE); + int emptyArity = arity(bitmap, PATTERN_EMPTY); + + if (nodeArity > 0) { + return SIZE_MORE_THAN_ONE; + } else { + switch (emptyArity) { + case 32: + return SIZE_EMPTY; + case 31: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } + } + + @Override + boolean hasNodes() { + return nodeArity() != 0; + } + + // NOTE: use 'final' when made collision node indepencent from compact node + @Override + int nodeArity() { + return Long.bitCount(filter(bitmap, PATTERN_NODE)); + // return arity(bitmap, PATTERN_NODE); + + // return cachedNodeArity; + } + + // NOTE: use 'final' when made collision node indepencent from compact node + @Override + CompactSetMultimapNode getNode(final int index) { + final int pIndex = slotArity() - 1 - index; + + return (CompactSetMultimapNode) getSlot(pIndex); + + // final long rareBase = staticRareBase(); + // + // final int untypedSlotArity = staticUntypedSlotArity(); + // final int pIndex = untypedSlotArity - 1 - index; + // + // return (CompactSetMultimapNode) getFromObjectRegion(this, rareBase, pIndex); + } + + void assertNodeInvariant() { + // return true; + // boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + // boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + // boolean inv3 = + // (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + // boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + // + // boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + // && ((this.payloadArity() + this.nodeArity()) == this.arity()); + // + // return inv1 && inv2 && inv3 && inv4 && inv5; + + // if (DEBUG) { + int[] arities = arities(bitmap); + + assert (TUPLE_LENGTH * arities[PATTERN_DATA_SINGLETON] + + TUPLE_LENGTH * arities[PATTERN_DATA_COLLECTION] + arities[PATTERN_NODE] == slotArity()); + + for (int i = 0; i < arities[PATTERN_DATA_SINGLETON]; i++) { + int offset = i * TUPLE_LENGTH; + + assert ((getSlot(offset + 0) instanceof io.usethesource.capsule.Set.Immutable) == false); + assert ((getSlot(offset + 1) instanceof io.usethesource.capsule.Set.Immutable) == false); + + assert ((getSlot(offset + 0) instanceof CompactSetMultimapNode) == false); + assert ((getSlot(offset + 1) instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arities[PATTERN_DATA_COLLECTION]; i++) { + int offset = (i + arities[PATTERN_DATA_SINGLETON]) * TUPLE_LENGTH; + + assert ((getSlot(offset + 0) instanceof io.usethesource.capsule.Set.Immutable) == false); + assert ((getSlot(offset + 1) instanceof io.usethesource.capsule.Set.Immutable) == true); + + assert ((getSlot(offset + 0) instanceof CompactSetMultimapNode) == false); + assert ((getSlot(offset + 1) instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arities[PATTERN_NODE]; i++) { + int offset = + (arities[PATTERN_DATA_SINGLETON] + arities[PATTERN_DATA_COLLECTION]) * TUPLE_LENGTH; + + assert ((getSlot(offset + i) instanceof io.usethesource.capsule.Set.Immutable) == false); + + assert ((getSlot(offset + i) instanceof CompactSetMultimapNode) == true); + } + } + // } + + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + final long updatedBitmap) { + final Class srcClass = this.getClass(); + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = RangecopyUtils.allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.bitmap = updatedBitmap; + + rangecopyObjectRegion(src, dst, arrayBase, staticSlotArity()); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndSetSingletonValue(final AtomicReference mutator, + final long doubledBitpos, final V val) { + final int index = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = RangecopyUtils.allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.bitmap = bitmap; + + final int slotArity = staticSlotArity(); + int pIndex = TUPLE_LENGTH * index + 1; + + rangecopyObjectRegion(src, arrayBase, dst, arrayBase, slotArity); + setInObjectRegion(dst, arrayBase, pIndex, val); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndSetCollectionValue(final AtomicReference mutator, + final long doubledBitpos, final io.usethesource.capsule.Set.Immutable valColl) { + final int index = collIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = RangecopyUtils.allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.bitmap = bitmap; + + final int slotArity = staticSlotArity(); + int pIndex = TUPLE_LENGTH * index + 1; + + rangecopyObjectRegion(src, arrayBase, dst, arrayBase, slotArity); + setInObjectRegion(dst, staticRareBase(), pIndex, valColl); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + static final CompactSetMultimapNode allocateHeapRegionAndSetBitmap( + final Class clazz, final long bitmap) { + try { + final CompactSetMultimapNode newInstance = + (CompactSetMultimapNode) unsafe.allocateInstance(clazz); + newInstance.bitmap = bitmap; + return newInstance; + } catch (ClassCastException | InstantiationException e) { + throw new RuntimeException(e); + } + } + + CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final int index, final CompactSetMultimapNode node) { + final Class srcClass = this.getClass(); + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = RangecopyUtils.allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.bitmap = bitmap; + + final int slotArity = staticSlotArity(); + final int pIndex = slotArity - 1 - index; + + // single copy spanning over all references + rangecopyObjectRegion(src, dst, arrayBase, slotArity); + setInObjectRegion(dst, arrayBase, pIndex, node); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndInsertSingleton(final AtomicReference mutator, + final long doubledBitpos, final K key, final V val) { + final int index = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = + allocateHeapRegion(specializationsByContentAndNodes, payloadArity + 1, untypedSlotArity); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_SINGLETON); + + final int pIndex = TUPLE_LENGTH * index; + + long offset = arrayBase; + long delta = 0; + + offset += rangecopyObjectRegion(src, dst, offset, pIndex); + delta += setInObjectRegionVarArgs(dst, offset, key, val); + offset += rangecopyObjectRegion(src, offset, dst, offset + delta, slotArity - pIndex); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + final AtomicReference mutator, final long doubledBitpos, final int indexOld, + final K key, final io.usethesource.capsule.Set.Immutable valColl) { + // final int indexOld = dataIndex(doubledBitpos); + final int indexNew = collIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity - 1, untypedSlotArity + 2); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_COLLECTION); + + final int pIndexOld = TUPLE_LENGTH * indexOld; + final int pIndexNew = TUPLE_LENGTH * (payloadArity - 1 + indexNew); + + /* TODO: test code below; not sure that length arguments are correct */ + + long offset = arrayBase; + long delta2 = addressSize * 2; + + offset += rangecopyObjectRegion(src, dst, offset, pIndexOld); + offset += rangecopyObjectRegion(src, offset + delta2, dst, offset, pIndexNew - pIndexOld); + setInObjectRegionVarArgs(dst, offset, key, valColl); + offset += rangecopyObjectRegion(src, dst, offset + delta2, slotArity - pIndexNew - 2); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndRemoveSingleton(final AtomicReference mutator, + final long doubledBitpos) { + final int indexOld = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + if (payloadArity == 1 && untypedSlotArity == 0) { + // TODO: check if this optimization can be performed in caller + return EMPTY_NODE; + } else { + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity - 1, untypedSlotArity); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_EMPTY); + + final int pIndexOld = TUPLE_LENGTH * indexOld; + + long offset = arrayBase; + offset += rangecopyObjectRegion(src, dst, offset, pIndexOld); + long delta = 2 * addressSize /* sizeOfInt() */; + offset += rangecopyObjectRegion(src, offset + delta, dst, offset, + (TUPLE_LENGTH * (payloadArity - 1) - pIndexOld + untypedSlotArity)); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + } + + /* + * Batch updated, necessary for removedAll. + */ + CompactSetMultimapNode copyAndRemoveCollection(final AtomicReference mutator, + final long doubledBitpos) { + final int indexOld = collIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + if (payloadArity == 0 && untypedSlotArity == TUPLE_LENGTH) { + // TODO: check if this optimization can be performed in caller + return EMPTY_NODE; + } else { + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity, untypedSlotArity - TUPLE_LENGTH); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_EMPTY); + + final int pIndexOld = TUPLE_LENGTH * (payloadArity + indexOld); + + long offset = arrayBase; + offset += rangecopyObjectRegion(src, dst, offset, pIndexOld); + long delta = 2 * addressSize /* sizeOfInt() */; + offset += rangecopyObjectRegion(src, offset + delta, dst, offset, + (TUPLE_LENGTH * (payloadArity - 1) - pIndexOld + untypedSlotArity)); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + } + + CompactSetMultimapNode copyAndMigrateFromSingletonToNode( + final AtomicReference mutator, final long doubledBitpos, final int indexOld, + final CompactSetMultimapNode node) { + // final int indexOld = dataIndex(doubledBitpos); + final int indexNew = nodeIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity - 1, untypedSlotArity + 1); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_NODE); + + final int pIndexOld = TUPLE_LENGTH * indexOld; + final int pIndexNew = (slotArity - 1) - 1 - indexNew; + + copyAndMigrateFromXxxToNode(src, dst, slotArity, pIndexOld, pIndexNew, node); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + private void copyAndMigrateFromXxxToNode(final CompactSetMultimapNode src, + final CompactSetMultimapNode dst, final int slotArity, final int pIndexOld, + final int pIndexNew, final CompactSetMultimapNode node) { + long offset = arrayBase; + long delta1 = addressSize; + long delta2 = 2 * addressSize; + + offset += rangecopyObjectRegion(src, dst, offset, pIndexOld); + offset += rangecopyObjectRegion(src, offset + delta2, dst, offset, pIndexNew - pIndexOld); + + setInObjectRegionVarArgs(dst, offset, node); + + offset += rangecopyObjectRegion(src, offset + delta2, dst, offset + delta1, + slotArity - pIndexNew - 2); + } + + CompactSetMultimapNode copyAndMigrateFromCollectionToNode( + final AtomicReference mutator, final long doubledBitpos, final int indexOld, + final CompactSetMultimapNode node) { + // final int indexOld = collIndex(doubledBitpos); + final int indexNew = nodeIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity, untypedSlotArity - TUPLE_LENGTH + 1); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_NODE); + + final int pIndexOld = TUPLE_LENGTH * (payloadArity + indexOld); + final int pIndexNew = (slotArity - 1) - 1 - indexNew; + + copyAndMigrateFromXxxToNode(src, dst, slotArity, pIndexOld, pIndexNew, node); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node) { // node get's unwrapped inside method + + final int indexOld = nodeIndex(doubledBitpos); + final int indexNew = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity + 1, untypedSlotArity - 1); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_SINGLETON); + + final int pIndexOld = slotArity - 1 - indexOld; + final int pIndexNew = TUPLE_LENGTH * indexNew; + + Object keyToInline = node.getSingletonKey(0); + Object valToInline = node.getSingletonValue(0); + + copyAndMigrateFromNodeToXxx(src, dst, slotArity, pIndexOld, pIndexNew, keyToInline, + valToInline); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndMigrateFromNodeToCollection( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node) { // node get's unwrapped inside method + + final int indexOld = nodeIndex(doubledBitpos); + final int indexNew = collIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity, untypedSlotArity - 1 + TUPLE_LENGTH); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_COLLECTION); + + final int pIndexOld = slotArity - 1 - indexOld; + final int pIndexNew = TUPLE_LENGTH * indexNew; + + Object keyToInline = node.getCollectionKey(0); + Object valToInline = node.getCollectionValue(0); + + copyAndMigrateFromNodeToXxx(src, dst, slotArity, pIndexOld, pIndexNew, keyToInline, + valToInline); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + private void copyAndMigrateFromNodeToXxx(final CompactSetMultimapNode src, + final CompactSetMultimapNode dst, final int slotArity, final int pIndexOld, + final int pIndexNew, Object keyToInline, Object valToInline) { + long offset = arrayBase; + long delta1 = addressSize; + long delta2 = delta1 * 2; + + offset += rangecopyObjectRegion(src, dst, offset, pIndexNew); + setInObjectRegionVarArgs(dst, offset, keyToInline, valToInline); + offset += rangecopyObjectRegion(src, offset, dst, offset + delta2, pIndexOld - pIndexNew); + offset += rangecopyObjectRegion(src, offset + delta1, dst, offset + delta2, + slotArity - pIndexOld - 1); + } + + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + final AtomicReference mutator, final long doubledBitpos, final K key, final V val) { + + // TODO: does not support src == dst yet for shifting + + final int indexOld = collIndex(doubledBitpos); + final int indexNew = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity + 1, untypedSlotArity - 2); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_SINGLETON); + + final int pIndexOld = TUPLE_LENGTH * (payloadArity + indexOld); + final int pIndexNew = TUPLE_LENGTH * indexNew; + + long offset = arrayBase; + long delta2 = addressSize * 2; + + offset += rangecopyObjectRegion(src, dst, offset, pIndexNew); + setInObjectRegionVarArgs(dst, offset, key, val); + offset += rangecopyObjectRegion(src, offset, dst, offset + delta2, pIndexOld - pIndexNew); + offset += rangecopyObjectRegion(src, dst, offset + delta2, slotArity - pIndexOld - 2); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + // TODO: fix hash collision support + static final CompactSetMultimapNode mergeTwoSingletonPairs(final K key0, + final V val0, final int keyHash0, final K key1, final V val1, final int keyHash1, + final int shift, EqualityComparator cmp) { + assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode.of(keyHash0, key0, setOf(val0), key1, setOf(val1)); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_SINGLETON); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_SINGLETON); + + if (mask0 < mask1) { + return nodeOf0x2(null, bitmap, key0, val0, key1, val1); + } else { + return nodeOf0x2(null, bitmap, key1, val1, key0, val0); + } + } else { + final CompactSetMultimapNode node = mergeTwoSingletonPairs(key0, val0, keyHash0, key1, + val1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf1x0(null, bitmap, node); + } + } + + // TODO: fix hash collision support + static final CompactSetMultimapNode mergeCollectionAndSingletonPairs(final K key0, + final io.usethesource.capsule.Set.Immutable valColl0, final int keyHash0, final K key1, + final V val1, + final int keyHash1, final int shift, EqualityComparator cmp) { + assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode.of(keyHash0, key0, valColl0, key1, setOf(val1)); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_COLLECTION); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_SINGLETON); + + // singleton before collection + return nodeOf2x1(null, bitmap, key1, val1, key0, valColl0); + } else { + final CompactSetMultimapNode node = mergeCollectionAndSingletonPairs(key0, valColl0, + keyHash0, key1, val1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf1x0(null, bitmap, node); + } + } + + // static final int index(final int bitmap, final int bitpos) { + // return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + // } + // + // static final int index(final int bitmap, final int mask, final int bitpos) { + // return (bitmap == -1) ? mask : index(bitmap, bitpos); + // } + + @Deprecated + int dataIndex(final long doubledBitpos) { + return index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + } + + @Deprecated + int collIndex(final long doubledBitpos) { + return index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + } + + @Deprecated + int nodeIndex(final long doubledBitpos) { + return index(bitmap, PATTERN_NODE, doubledBitpos); + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + return cmp.equals(getSingletonKey(index), key); + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + return cmp.equals(getCollectionKey(index), key); + } + default: + return false; + } + } + + @Override + boolean containsTuple(final K key, final V val, final int keyHash, final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + + final AbstractSetMultimapNode subNode = getNode(index); + return subNode.containsTuple(key, val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(index); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(index); + return cmp.equals(currentVal, val); + } + + return false; + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(index); + if (cmp.equals(currentKey, key)) { + + final io.usethesource.capsule.Set.Immutable currentValColl = getCollectionValue( + index); + return currentValColl.contains(val); + } + + return false; + } + default: + return false; + } + } + + @Override + Optional> findByKey(final K key, final int keyHash, + final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + + final AbstractSetMultimapNode subNode = getNode(index); + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(index); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(index); + return Optional.of(setOf(currentVal)); + } + + return Optional.empty(); + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(index); + if (cmp.equals(currentKey, key)) { + + final io.usethesource.capsule.Set.Immutable currentValColl = getCollectionValue( + index); + return Optional.of(currentValColl); + } + + return Optional.empty(); + } + default: + return Optional.empty(); + } + } + + @Override + CompactSetMultimapNode inserted(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = subNode.inserted(mutator, key, val, + keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + if (cmp.equals(currentVal, val)) { + return this; + } else { + // migrate from singleton to collection + final io.usethesource.capsule.Set.Immutable valColl = setOf(currentVal, val); + + details.modified(); + return copyAndMigrateFromSingletonToCollection(mutator, doubledBitpos, dataIndex, + currentKey, valColl); + } + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, dataIndex, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final io.usethesource.capsule.Set.Immutable currentCollVal = getCollectionValue( + collIndex); + + if (currentCollVal.contains(val)) { + return this; + } else { + // add new mapping + final io.usethesource.capsule.Set.Immutable newCollVal = currentCollVal + .__insert(val); + + details.modified(); + return copyAndSetCollectionValue(mutator, doubledBitpos, newCollVal); + } + } else { + // prefix-collision (case: collection x singleton) + final io.usethesource.capsule.Set.Immutable currentValNode = getCollectionValue( + collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, collIndex, + subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertSingleton(mutator, doubledBitpos, key, val); + } + } + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + // update singleton value + details.updated(currentVal); + return copyAndSetSingletonValue(mutator, doubledBitpos, val); + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, dataIndex, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final io.usethesource.capsule.Set.Immutable currentCollVal = getCollectionValue( + collIndex); + + // migrate from collection to singleton + details.updated(currentCollVal); + return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, currentCollKey, + val); + } else { + // prefix-collision (case: collection x singleton) + final io.usethesource.capsule.Set.Immutable currentValNode = getCollectionValue( + collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, collIndex, + subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertSingleton(mutator, doubledBitpos, key, val); + } + } + } + + @Override + CompactSetMultimapNode removed(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.removed(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (slotArity() == 0) { + if (shift == 0) { + // singleton remaining + final long doubledBitposAtShift0 = doubledBitpos(bitpos(doubledMask(keyHash, 0))); + + final long updatedBitmapAtShift0 = + setBitPattern(doubledBitposAtShift0, subNodeNew.patternOfSingleton()); + + return subNodeNew.copyAndUpdateBitmaps(mutator, updatedBitmapAtShift0); + } else { + // escalate (singleton or empty) result + return subNodeNew; + } + } else { + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + } + + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(dataIndex); + if (cmp.equals(currentVal, val)) { + + // remove mapping + details.updated(val); + return copyAndRemoveSingleton(mutator, doubledBitpos); + } else { + return this; + } + } else { + return this; + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(collIndex); + if (cmp.equals(currentKey, key)) { + + final io.usethesource.capsule.Set.Immutable currentValColl = getCollectionValue( + collIndex); + if (currentValColl.contains(val)) { + + // remove mapping + details.updated(val); + + final io.usethesource.capsule.Set.Immutable newValColl = currentValColl + .__remove(val); + + if (newValColl.size() == 1) { + // TODO: investigate options for unboxing singleton collections + V remainingVal = newValColl.iterator().next(); + return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, key, + remainingVal); + } else { + return copyAndSetCollectionValue(mutator, doubledBitpos, newValColl); + } + } else { + return this; + } + } else { + return this; + } + } + default: + return this; + } + } + + final static boolean hasSingleNode(int[] arities) { + return arities[PATTERN_EMPTY] == 31 && arities[PATTERN_NODE] == 1; + } + + final static boolean hasTwoPayloads(int[] arities) { + return arities[PATTERN_EMPTY] == 30 && arities[PATTERN_NODE] == 0; + } + + enum State { + EMPTY, NODE, PAYLOAD, PAYLOAD_RARE + } + + static final State toState(final int pattern) { + // final State[] states = {State.EMPTY, State.NODE, State.PAYLOAD, State.PAYLOAD_RARE}; + // return states[pattern]; + + switch (pattern) { + case PATTERN_EMPTY: + return State.EMPTY; + case PATTERN_NODE: + return State.NODE; + case PATTERN_DATA_SINGLETON: + return State.PAYLOAD; + default: + return State.PAYLOAD_RARE; + } + } + + @Override + CompactSetMultimapNode removedAll(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.removedAll(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (slotArity() == 1) { + if (shift == 0) { + // singleton remaining + final long doubledBitposAtShift0 = doubledBitpos(bitpos(doubledMask(keyHash, 0))); + + final long updatedBitmapAtShift0 = + setBitPattern(doubledBitposAtShift0, subNodeNew.patternOfSingleton()); + + return subNodeNew.copyAndUpdateBitmaps(mutator, updatedBitmapAtShift0); + } else { + // escalate (singleton or empty) result + return subNodeNew; + } + } else { + // // inline value (move to front) + // final State subNodeState = subNodeNew.stateOfSingleton(); + // + //// switch (subNodeState) { + //// case EMPTY: + //// case NODE: + //// case PAYLOAD: + //// return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + //// case PAYLOAD_RARE: + //// return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + //// } + // + // if (subNodeState == State.PAYLOAD) { + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // } else { + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // } + + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + } + + // // inline value (move to front) + // final int subNodePattern = subNodeNew.patternOfSingleton(); + // + // if (subNodePattern == PATTERN_DATA_SINGLETON) { + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // } else { + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // } + + // switch (subNodePattern) { + // case PATTERN_DATA_SINGLETON: + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // case PATTERN_DATA_COLLECTION: + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // default: + // return null; + // } + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(dataIndex); + + details.updated(currentVal); + return copyAndRemoveSingleton(mutator, doubledBitpos); + } else { + return this; + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(collIndex); + if (cmp.equals(currentKey, key)) { + + final io.usethesource.capsule.Set.Immutable currentValColl = getCollectionValue( + collIndex); + + details.updated(currentValColl); + return copyAndRemoveCollection(mutator, doubledBitpos); + } else { + return this; + } + } + default: + return this; + } + } + + int patternOfSingleton() { + assert this.sizePredicate() == SIZE_ONE; + + long bitmap = this.bitmap(); + + final int doubledMask = Long.numberOfTrailingZeros(bitmap) / 2 * 2; + final int pattern = pattern(bitmap, doubledMask); + + return pattern; + } + + @Deprecated + State stateOfSingleton() { + assert this.sizePredicate() == SIZE_ONE; + + long bitmap = this.bitmap(); + + final int doubledMask = Long.numberOfTrailingZeros(bitmap) / 2 * 2; + final int pattern = pattern(bitmap, doubledMask); + + return toState(pattern); + } + + @Deprecated + EitherSingletonOrCollection.Type typeOfSingleton() { + final int pattern = patternOfSingleton(); + + if (pattern == PATTERN_DATA_SINGLETON) { + return EitherSingletonOrCollection.Type.SINGLETON; + } else { + return EitherSingletonOrCollection.Type.COLLECTION; + } + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + long bitmap = this.bitmap(); + + int[] arities = arities(bitmap); + + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < arities[PATTERN_DATA_SINGLETON]; i++) { + final byte pos = -1; // TODO: recoverMask(dataMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getSingletonKey(i)), + Objects.hashCode(getSingletonValue(i)))); + + if (!((i + 1) == arities[PATTERN_DATA_SINGLETON])) { + bldr.append(", "); + } + } + + if (arities[PATTERN_DATA_SINGLETON] > 0 && arities[PATTERN_DATA_COLLECTION] > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arities[PATTERN_DATA_COLLECTION]; i++) { + final byte pos = -1; // TODO: recoverMask(collMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getCollectionKey(i)), + Objects.hashCode(getCollectionValue(i)))); + + if (!((i + 1) == arities[PATTERN_DATA_COLLECTION])) { + bldr.append(", "); + } + } + + if (arities[PATTERN_DATA_COLLECTION] > 0 && arities[PATTERN_NODE] > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arities[PATTERN_NODE]; i++) { + final byte pos = -1; // TODO: recoverMask(nodeMap, (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == arities[PATTERN_NODE])) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + CompactSetMultimapNode that = (CompactSetMultimapNode) other; + if (bitmap() != that.bitmap()) { + return false; + } + + return _do_rangecompareObjectRegion(this, that, arrayBase, slotArity()); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf1x0(final AtomicReference mutator, + final long bitmap, final Object slot0) { + return new SetMultimap0To1Node<>(mutator, bitmap, slot0); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf0x1(final AtomicReference mutator, + final long bitmap, final K key1, final V val1) { + return new SetMultimap1To0Node<>(mutator, bitmap, key1, val1); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf0x2(final AtomicReference mutator, + final long bitmap, final K key1, final V val1, final K key2, final V val2) { + return new SetMultimap2To0Node<>(mutator, bitmap, key1, val1, key2, val2); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf4x0(final AtomicReference mutator, + final long bitmap, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + return new SetMultimap0To4Node<>(mutator, bitmap, slot0, slot1, slot2, slot3); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf2x0(final AtomicReference mutator, + final long bitmap, final Object slot0, final Object slot1) { + return new SetMultimap0To2Node<>(mutator, bitmap, slot0, slot1); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf2x1(final AtomicReference mutator, + final long bitmap, final K key1, final V val1, final Object slot0, final Object slot1) { + return new SetMultimap1To2Node<>(mutator, bitmap, key1, val1, slot0, slot1); + } + + } + + private static abstract class AbstractHashCollisionNode + extends CompactSetMultimapNode { + + // TODO: remove constructor and stored properties within CompactSetMultimapNode + AbstractHashCollisionNode() { + super(null, 0L); + } + + static final > AbstractHashCollisionNode of( + final int hash, final K key0, final VS valColl0, final K key1, final VS valColl1) { + return new HashCollisionNode<>(hash, key0, valColl0, key1, valColl1); + } + + private static final RuntimeException UOE_BOILERPLATE = new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + private static final Supplier UOE_FACTORY = + () -> new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + @Override + CompactSetMultimapNode copyAndSetSingletonValue(AtomicReference mutator, + long doubledBitpos, V val) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndSetCollectionValue(AtomicReference mutator, + long doubledBitpos, io.usethesource.capsule.Set.Immutable valColl) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndInsertSingleton(AtomicReference mutator, + long doubledBitpos, K key, V val) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(AtomicReference mutator, + long doubledBitpos) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveCollection(AtomicReference mutator, + long doubledBitpos) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToCollection(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + long bitmap) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + AtomicReference mutator, long doubledBitpos, K key, V val) { + throw UOE_FACTORY.get(); + } + + @Override + Type typeOfSingleton() { + throw UOE_FACTORY.get(); + } + + @Override + int patternOfSingleton() { + throw UOE_FACTORY.get(); + } + } + + private static final class HashCollisionNode extends AbstractHashCollisionNode { + + private final int hash; + private final List>> collisionContent; + + HashCollisionNode(final int hash, final K key0, + final io.usethesource.capsule.Set.Immutable valColl0, final K key1, + final io.usethesource.capsule.Set.Immutable valColl1) { + this(hash, Arrays.asList(entryOf(key0, valColl0), entryOf(key1, valColl1))); + } + + HashCollisionNode(final int hash, + final List>> collisionContent) { + this.hash = hash; + this.collisionContent = collisionContent; + } + + private static final RuntimeException UOE = new UnsupportedOperationException(); + + private static final Supplier UOE_NOT_YET_IMPLEMENTED_FACTORY = + () -> new UnsupportedOperationException("Not yet implemented @ HashCollisionNode."); + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + CompactSetMultimapNode getNode(int index) { + throw UOE; + } + + @Override + boolean hasPayload(EitherSingletonOrCollection.Type type) { + switch (type) { + case SINGLETON: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).findAny() + .isPresent(); + case COLLECTION: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).findAny() + .isPresent(); + } + throw new RuntimeException(); + } + + @Override + int payloadArity(EitherSingletonOrCollection.Type type) { + switch (type) { + case SINGLETON: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).count(); + case COLLECTION: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).count(); + } + throw new RuntimeException(); + } + + @Override + K getSingletonKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getKey(); + } + + @Override + V getSingletonValue(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getValue().stream().findAny().get(); + } + + @Override + K getCollectionKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getKey(); + } + + @Override + io.usethesource.capsule.Set.Immutable getCollectionValue(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getValue(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return collisionContent.size() * 2; + } + + @Override + Object getSlot(int index) { + if (index % 2 == 0) { + return collisionContent.get(index / 2).getKey(); + } else { + return collisionContent.get(index / 2).getValue(); + } + } + + @Override + boolean containsKey(K key, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny() + .isPresent(); + } + + @Override + boolean containsTuple(K key, V val, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) + && entry.getValue().containsEquivalent(val, cmp.toComparator())) + .findAny().isPresent(); + } + + @Override + Optional> findByKey(K key, int keyHash, int shift, + EqualityComparator cmp) { + throw UOE_NOT_YET_IMPLEMENTED_FACTORY.get(); + } + + @Override + CompactSetMultimapNode inserted(AtomicReference mutator, K key, V val, + int keyHash, int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + if (values.containsEquivalent(val, cmp.toComparator())) { + // contains key and value + details.unchanged(); + return this; + + } else { + // contains key but not value + + Function>, Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = + values.__insertEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + // TODO does not check that remainder is unmodified + assert updatedCollisionContent.size() == collisionContent.size(); + assert updatedCollisionContent.contains(optionalTuple.get()) == false; + // assert updatedCollisionContent.contains(entryOf(key, values.__insertEquivalent(val, + // cmp.toComparator()))); + assert updatedCollisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) + && entry.getValue().containsEquivalent(val, cmp.toComparator())) + .findAny().isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder() + .add(entryOf(key, setOf(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + assert updatedCollisionContent.size() == collisionContent.size() + 1; + assert updatedCollisionContent.containsAll(collisionContent); + // assert updatedCollisionContent.contains(entryOf(key, setOf(val))); + assert updatedCollisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey()) + && Objects.equals(setOf(val), entry.getValue())).findAny().isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode updated(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key -> replace val anyways + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = values + .__insertEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + if (values.size() == 1) { + details.updated(values.stream().findAny().get()); // unbox singleton + } else { + details.updated(values); + } + + return new HashCollisionNode(hash, updatedCollisionContent); + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder() + .add(entryOf(key, setOf(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode removed(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + if (values.containsEquivalent(val, cmp.toComparator())) { + // contains key and value -> remove mapping + + final List>> updatedCollisionContent; + + if (values.size() == 1) { + updatedCollisionContent = collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry != optionalTuple.get()) + .collect(Collectors.toList()); + } else { + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = + values.__removeEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + } + + details.updated(val); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + details.unchanged(); + return this; + } + + @Override + State stateOfSingleton() { + return null; + } + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueSingletonCursor; + protected int currentValueSingletonLength; + protected int currentValueCollectionCursor; + protected int currentValueCollectionLength; + protected AbstractSetMultimapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractSetMultimapNode[] nodes = new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapIterator(AbstractSetMultimapNode rootNode) { + int nodeArity = rootNode.nodeArity(); + if (nodeArity != 0) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = nodeArity; + } + + int emptyArity = rootNode.emptyArity(); + if (emptyArity + nodeArity < 32) { + currentValueNode = rootNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = rootNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = rootNode.payloadArity(COLLECTION); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractSetMultimapNode nextNode = + nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + int nodeArity = nextNode.nodeArity(); + if (nodeArity != 0) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nodeArity; + } + + // int emptyArity = nextNode.emptyArity(); + // if (emptyArity + nodeArity < 32) { + if (nextNode.hasPayload(SINGLETON) || nextNode.hasPayload(COLLECTION)) { + // if (payloadAritySingleton != 0 || payloadArityCollection != 0) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = nextNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = nextNode.payloadArity(Type.COLLECTION); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueSingletonCursor < currentValueSingletonLength + || currentValueCollectionCursor < currentValueCollectionLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetMultimapKeyIterator extends AbstractSetMultimapIterator + implements Iterator { + + SetMultimapKeyIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return currentValueNode.getSingletonKey(currentValueSingletonCursor++); + } else { + return currentValueNode.getCollectionKey(currentValueCollectionCursor++); + } + } + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIteratorOffsetHistogram { + + private static final int MAX_DEPTH = 7; + private static final int START_CATEGORY = PATTERN_DATA_SINGLETON; + + protected AbstractSetMultimapNode payloadNode; + protected int payloadCategoryCursor; + + protected long payloadCategoryOffset; + protected long payloadCategoryOffsetEnd; + + protected long payloadTotalOffsetEnd; + + private int stackLevel = -1; + private final long[] stackOfOffsetsAndOutOfBounds = new long[MAX_DEPTH * 2]; + private final AbstractSetMultimapNode[] stackOfNodes = + new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapNode topOfStackNode; + long nodeCursorAddress; + long nodeLengthAddress; + + AbstractSetMultimapIteratorOffsetHistogram(AbstractSetMultimapNode rootNode) { + long offsetNodesEnd = ((CompactSetMultimapNode) rootNode).staticNodeBase(); + long offsetNodes = + offsetNodesEnd - ((CompactSetMultimapNode) rootNode).lengthInBytes(PATTERN_NODE); + long offsetPayload = CompactSetMultimapNode.arrayBase; + + if (offsetNodes < offsetNodesEnd) { + pushNode(rootNode, offsetNodes, offsetNodesEnd); + } + + if (offsetPayload < offsetNodes) { + setPayloadNode(rootNode, offsetPayload, offsetNodes); + } + } + + private void pushNode(AbstractSetMultimapNode node, long offsetStart, long offsetEnd) { + if (stackLevel >= 0) { + // save current cursor + stackOfOffsetsAndOutOfBounds[stackLevel * 2] = nodeCursorAddress; + } + + final int nextStackLevel = ++stackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + stackOfNodes[nextStackLevel] = node; + stackOfOffsetsAndOutOfBounds[nextCursorIndex] = offsetStart; + stackOfOffsetsAndOutOfBounds[nextLengthIndex] = offsetEnd; + + // load next cursor + topOfStackNode = node; + nodeCursorAddress = offsetStart; + nodeLengthAddress = offsetEnd; + } + + private final void popNode() { + stackOfNodes[stackLevel--] = null; + + if (stackLevel >= 0) { + // load prevous cursor + final int previousStackLevel = stackLevel; + final int previousCursorIndex = previousStackLevel * 2; + final int previousLengthIndex = previousCursorIndex + 1; + + topOfStackNode = stackOfNodes[previousStackLevel]; + nodeCursorAddress = stackOfOffsetsAndOutOfBounds[previousCursorIndex]; + nodeLengthAddress = stackOfOffsetsAndOutOfBounds[previousLengthIndex]; + } + } + + private final AbstractSetMultimapNode consumeNode() { + AbstractSetMultimapNode nextNode = + getFromObjectRegionAndCast(topOfStackNode, nodeCursorAddress); + nodeCursorAddress += addressSize; + + if (nodeCursorAddress == nodeLengthAddress) { + popNode(); + } + + return nextNode; + } + + private void setPayloadNode(final AbstractSetMultimapNode node, long categoryOffsetStart, + long overallOffsetEnd) { + payloadNode = node; + payloadCategoryCursor = START_CATEGORY; + + payloadCategoryOffset = categoryOffsetStart; + payloadCategoryOffsetEnd = + categoryOffsetStart + ((CompactSetMultimapNode) node).lengthInBytes(START_CATEGORY); + + payloadTotalOffsetEnd = overallOffsetEnd; + } + + protected boolean searchNextPayloadCategory() { + do { + payloadCategoryOffsetEnd = ((CompactSetMultimapNode) payloadNode) + .offsetEnd(++payloadCategoryCursor, payloadCategoryOffsetEnd); + } while (payloadCategoryOffset == payloadCategoryOffsetEnd); + + return true; + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + boolean found = false; + while (!found && stackLevel >= 0) { + final AbstractSetMultimapNode nextNode = consumeNode(); + + long offsetNodesEnd = ((CompactSetMultimapNode) nextNode).staticNodeBase(); + long offsetNodes = + offsetNodesEnd - ((CompactSetMultimapNode) nextNode).lengthInBytes(PATTERN_NODE); + long offsetPayload = CompactSetMultimapNode.arrayBase; + + if (offsetNodes < offsetNodesEnd) { + pushNode(nextNode, offsetNodes, offsetNodesEnd); + } + + if (offsetPayload < offsetNodes) { + setPayloadNode(nextNode, offsetPayload, offsetNodes); + found = true; + } + } + + return found; + } + + protected boolean advanceToNext() { + return (payloadCategoryOffset < payloadTotalOffsetEnd && searchNextPayloadCategory()) + || searchNextValueNode(); + } + + public boolean hasNext() { + return payloadCategoryOffset < payloadCategoryOffsetEnd || advanceToNext(); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetMultimapKeyIteratorOffsetHistogram + extends AbstractSetMultimapIteratorOffsetHistogram implements Iterator { + + SetMultimapKeyIteratorOffsetHistogram(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + switch (payloadCategoryCursor) { + case PATTERN_DATA_SINGLETON: + case PATTERN_DATA_COLLECTION: + long nextOffset = payloadCategoryOffset; + payloadCategoryOffset = nextOffset + 2 * addressSize; + + return getFromObjectRegionAndCast(payloadNode, nextOffset); + default: + throw new IllegalStateException(); + } + } + } + + } + + protected static class SetMultimapNativeTupleIteratorOffsetHistogram extends + AbstractSetMultimapIteratorOffsetHistogram implements Iterator> { + + SetMultimapNativeTupleIteratorOffsetHistogram(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + switch (payloadCategoryCursor) { + case PATTERN_DATA_SINGLETON: + case PATTERN_DATA_COLLECTION: + long nextOffset = payloadCategoryOffset; + + K nextKey = getFromObjectRegionAndCast(payloadNode, nextOffset); + nextOffset += addressSize; + Object nextVal = getFromObjectRegion(payloadNode, nextOffset); + nextOffset += addressSize; + + payloadCategoryOffset = nextOffset; + + return entryOf(nextKey, nextVal); + default: + throw new IllegalStateException(); + } + } + } + + } + + protected static class SetMultimapFlattenedTupleIteratorOffsetHistogram extends + AbstractSetMultimapIteratorOffsetHistogram implements Iterator> { + + private K cachedKey = null; + private Iterator cachedValueSetIterator = Collections.emptyIterator(); + + SetMultimapFlattenedTupleIteratorOffsetHistogram(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public boolean hasNext() { + return cachedValueSetIterator.hasNext() || super.hasNext(); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + switch (payloadCategoryCursor) { + case PATTERN_DATA_SINGLETON: { + long nextOffset = payloadCategoryOffset; + + K nextKey = getFromObjectRegionAndCast(payloadNode, nextOffset); + nextOffset += addressSize; + V nextVal = getFromObjectRegionAndCast(payloadNode, nextOffset); + nextOffset += addressSize; + + payloadCategoryOffset = nextOffset; + + return entryOf(nextKey, nextVal); + } + case PATTERN_DATA_COLLECTION: { + if (cachedValueSetIterator.hasNext() == false) { + long nextOffset = payloadCategoryOffset; + + K nextKey = getFromObjectRegionAndCast(payloadNode, nextOffset); + nextOffset += addressSize; + io.usethesource.capsule.Set.Immutable nextValueSet = getFromObjectRegionAndCast( + payloadNode, nextOffset); + nextOffset += addressSize; + + payloadCategoryOffset = nextOffset; + + cachedKey = nextKey; + cachedValueSetIterator = nextValueSet.iterator(); + } + + return entryOf(cachedKey, cachedValueSetIterator.next()); + } + default: + throw new IllegalStateException(); + } + } + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIteratorSlotHistogram { + + private static final int MAX_DEPTH = 7; + + protected AbstractSetMultimapNode payloadNode; + protected int payloadCategoryCursor; + + protected int payloadCategoryOffset; + protected int payloadCategoryOffsetEnd; + + protected int payloadTotalOffsetEnd; + + protected int[] histogramOffsets; + + private int stackLevel = -1; + private final int[] stackOfOffsetsAndOutOfBounds = new int[MAX_DEPTH * 2]; + private final AbstractSetMultimapNode[] stackOfNodes = + new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapIteratorSlotHistogram(AbstractSetMultimapNode rootNode) { + int[] offsets = rootNode.slotRangeTuples(); + + int offsetNodes = offsets[2]; + int offsetNodesEnd = offsets[3]; + int offsetCategory1 = offsets[4]; + int offsetCategory1End = offsets[5]; + + if (offsetNodes != offsetNodesEnd) { + stackLevel = 0; + + stackOfNodes[0] = rootNode; + stackOfOffsetsAndOutOfBounds[0] = offsetNodes; + stackOfOffsetsAndOutOfBounds[1] = offsetNodesEnd; + } + + if (offsetCategory1 != offsetNodes) { + payloadNode = rootNode; + payloadCategoryCursor = PATTERN_DATA_SINGLETON; + payloadCategoryOffset = offsetCategory1; + payloadCategoryOffsetEnd = offsetCategory1End; + payloadTotalOffsetEnd = offsetNodes; + } + + histogramOffsets = offsets; + } + + protected boolean searchNextPayloadCategory() { + do { + payloadCategoryOffsetEnd = histogramOffsets[2 * ++payloadCategoryCursor + 1]; + } while (payloadCategoryOffset == payloadCategoryOffsetEnd); + + return true; + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (stackLevel >= 0) { + final int currentCursorIndex = stackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursorAddress = stackOfOffsetsAndOutOfBounds[currentCursorIndex]; + final int nodeLengthAddress = stackOfOffsetsAndOutOfBounds[currentLengthIndex]; + + if (nodeCursorAddress < nodeLengthAddress) { + final AbstractSetMultimapNode nextNode = + (AbstractSetMultimapNode) stackOfNodes[stackLevel].getSlot(nodeCursorAddress); + stackOfOffsetsAndOutOfBounds[currentCursorIndex] += 1; + + int[] offsets = nextNode.slotRangeTuples(); + + int offsetNodes = offsets[2]; + int offsetNodesEnd = offsets[3]; + int offsetCategory1 = offsets[4]; + int offsetCategory1End = offsets[5]; + + if (offsetNodes != offsetNodesEnd) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++stackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + stackOfNodes[nextStackLevel] = nextNode; + stackOfOffsetsAndOutOfBounds[nextCursorIndex] = offsetNodes; + stackOfOffsetsAndOutOfBounds[nextLengthIndex] = offsetNodesEnd; + } + + if (offsetCategory1 != offsetNodes) { + payloadNode = nextNode; + payloadCategoryCursor = PATTERN_DATA_SINGLETON; + payloadCategoryOffset = offsetCategory1; + payloadCategoryOffsetEnd = offsetCategory1End; + payloadTotalOffsetEnd = offsetNodes; + + histogramOffsets = offsets; + return true; + } + + } else { + stackLevel--; + } + } + + return false; + } + + protected boolean advanceToNext() { + return (payloadCategoryOffset < payloadTotalOffsetEnd && searchNextPayloadCategory()) + || searchNextValueNode(); + } + + public boolean hasNext() { + return payloadCategoryOffset < payloadCategoryOffsetEnd || advanceToNext(); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetMultimapKeyIteratorSlotHistogram + extends AbstractSetMultimapIteratorSlotHistogram implements Iterator { + + SetMultimapKeyIteratorSlotHistogram(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + switch (payloadCategoryCursor) { + case PATTERN_DATA_SINGLETON: + case PATTERN_DATA_COLLECTION: + int nextSlot = payloadCategoryOffset; + payloadCategoryOffset = nextSlot + 2; + + return (K) payloadNode.getSlot(nextSlot); + default: + throw new IllegalStateException(); + } + } + } + + } + + protected static class SetMultimapNativeTupleIteratorSlotHistogram extends + AbstractSetMultimapIteratorSlotHistogram implements Iterator> { + + SetMultimapNativeTupleIteratorSlotHistogram(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + switch (payloadCategoryCursor) { + case PATTERN_DATA_SINGLETON: + case PATTERN_DATA_COLLECTION: + int nextSlot = payloadCategoryOffset; + + K nextKey = (K) payloadNode.getSlot(nextSlot++); + // nextSlot += 1; + Object nextVal = payloadNode.getSlot(nextSlot++); + // nextSlot += 1; + + payloadCategoryOffset = nextSlot; + + return entryOf(nextKey, nextVal); + default: + throw new IllegalStateException(); + } + } + } + + } + + protected static class SetMultimapFlattenedTupleIteratorSlotHistogram + extends AbstractSetMultimapIteratorSlotHistogram implements Iterator> { + + private K cachedKey = null; + private Iterator cachedValueSetIterator = Collections.emptyIterator(); + + SetMultimapFlattenedTupleIteratorSlotHistogram(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public boolean hasNext() { + return cachedValueSetIterator.hasNext() || super.hasNext(); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + switch (payloadCategoryCursor) { + case PATTERN_DATA_SINGLETON: { + int nextSlot = payloadCategoryOffset; + + K nextKey = (K) payloadNode.getSlot(nextSlot++); + // nextSlot += 1; + V nextVal = (V) payloadNode.getSlot(nextSlot++); + // nextSlot += 1; + + payloadCategoryOffset = nextSlot; + + return entryOf(nextKey, nextVal); + } + case PATTERN_DATA_COLLECTION: { + if (cachedValueSetIterator.hasNext() == false) { + int nextSlot = payloadCategoryOffset; + + K nextKey = (K) payloadNode.getSlot(nextSlot++); + // nextSlot += 1; + io.usethesource.capsule.Set.Immutable nextValueSet = (io.usethesource.capsule.Set.Immutable) payloadNode + .getSlot(nextSlot); + // nextSlot += 1; + + payloadCategoryOffset = nextSlot; + + cachedKey = nextKey; + cachedValueSetIterator = nextValueSet.iterator(); + } + + return entryOf(cachedKey, cachedValueSetIterator.next()); + } + default: + throw new IllegalStateException(); + } + } + } + + private static class FlatteningIterator implements Iterator> { + + final Iterator> entryIterator; + + K lastKey = null; + Iterator lastIterator = Collections.emptyIterator(); + + public FlatteningIterator(Iterator> entryIterator) { + this.entryIterator = entryIterator; + } + + @Override + public boolean hasNext() { + if (lastIterator.hasNext()) { + return true; + } else { + return entryIterator.hasNext(); + } + } + + @Override + public Entry next() { + assert hasNext(); + + if (lastIterator.hasNext()) { + return entryOf(lastKey, lastIterator.next()); + } else { + lastKey = null; + + Entry nextEntry = entryIterator.next(); + + Object singletonOrSet = nextEntry.getValue(); + + if (singletonOrSet instanceof io.usethesource.capsule.api.experimental.Set) { + io.usethesource.capsule.api.experimental.Set set = (io.usethesource.capsule.api.experimental.Set) singletonOrSet; + + lastKey = nextEntry.getKey(); + lastIterator = ((Iterable) set).iterator(); + + return entryOf(lastKey, lastIterator.next()); + } else { + return (Map.Entry) nextEntry; + } + } + } + + } + + protected static class SetMultimapValueIterator extends AbstractSetMultimapIterator + implements Iterator> { + + SetMultimapValueIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public io.usethesource.capsule.Set.Immutable next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return setOf(currentValueNode.getSingletonValue(currentValueSingletonCursor++)); + } else { + return currentValueNode.getCollectionValue(currentValueCollectionCursor++); + } + } + } + + } + + protected static class SetMultimapNativeTupleIterator + extends AbstractSetMultimapIterator implements Iterator> { + + SetMultimapNativeTupleIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + final K currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + final Object currentValue = + currentValueNode.getSingletonValue(currentValueSingletonCursor); + currentValueSingletonCursor++; + + return AbstractSpecialisedImmutableMap.entryOf(currentKey, currentValue); + } else { + final K currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + final Object currentValue = + currentValueNode.getCollectionValue(currentValueCollectionCursor); + currentValueCollectionCursor++; + + return AbstractSpecialisedImmutableMap.entryOf(currentKey, currentValue); + } + } + } + + } + + protected static class SetMultimapTupleIterator extends AbstractSetMultimapIterator + implements Iterator { + + final BiFunction tupleOf; + + K currentKey = null; + V currentValue = null; + Iterator currentSetIterator = Collections.emptyIterator(); + + SetMultimapTupleIterator(AbstractSetMultimapNode rootNode, + final BiFunction tupleOf) { + super(rootNode); + this.tupleOf = tupleOf; + } + + @Override + public boolean hasNext() { + if (currentSetIterator.hasNext()) { + return true; + } else { + if (super.hasNext()) { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + currentSetIterator = Collections + .singleton(currentValueNode.getSingletonValue(currentValueSingletonCursor)) + .iterator(); + currentValueSingletonCursor++; + } else { + currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + currentSetIterator = + currentValueNode.getCollectionValue(currentValueCollectionCursor).iterator(); + currentValueCollectionCursor++; + } + + return true; + } else { + return false; + } + } + } + + @Override + public T next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + currentValue = currentSetIterator.next(); + return tupleOf.apply(currentKey, currentValue); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieSetMultimap_BleedingEdgeNodeIterator + implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieSetMultimap_BleedingEdgeNodeIterator(AbstractSetMultimapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractSetMultimapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieSetMultimap_BleedingEdge + implements SetMultimap.Transient { + + private final EqualityComparator cmp; + + final private AtomicReference mutator; + private AbstractSetMultimapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieSetMultimap_BleedingEdge( + TrieSetMultimap_HHAMT_Specialized trieSetMultimap_BleedingEdge) { + this.cmp = trieSetMultimap_BleedingEdge.cmp; + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieSetMultimap_BleedingEdge.rootNode; + this.hashCode = trieSetMultimap_BleedingEdge.hashCode; + this.cachedSize = trieSetMultimap_BleedingEdge.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.equals(iterator.next(), o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get().contains(val); + } else { + return false; + } + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public boolean __insert(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean union(final SetMultimap setMultimap) { + boolean modified = false; + + for (Map.Entry entry : setMultimap.entrySet()) { + modified |= this.__insert(entry.getKey(), entry.getValue()); + } + + return modified; + } + + @Override + public boolean __remove(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return false; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new TransientSetMultimapKeyIterator<>(this); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(Set::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + return new TransientSetMultimapTupleIterator<>(this, + AbstractSpecialisedImmutableMap::entryOf); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new TransientSetMultimapTupleIterator<>(this, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + public static class TransientSetMultimapKeyIterator extends SetMultimapKeyIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + K lastKey; + + public TransientSetMultimapKeyIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapValueIterator + extends SetMultimapValueIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapValueIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public io.usethesource.capsule.Set.Immutable next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapTupleIterator + extends SetMultimapTupleIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapTupleIterator( + final TransientTrieSetMultimap_BleedingEdge collection, + final BiFunction tupleOf) { + super(collection.rootNode, tupleOf); + this.collection = collection; + } + + @Override + public T next() { + return super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(currentKey, currentValue); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieSetMultimap_BleedingEdge.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieSetMultimap_BleedingEdge) { + TransientTrieSetMultimap_BleedingEdge that = + (TransientTrieSetMultimap_BleedingEdge) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + final io.usethesource.capsule.Set.Immutable valColl = (io.usethesource.capsule.Set.Immutable) entry + .getValue(); + + if (!cmp.equals(result.get(), valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public SetMultimap.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieSetMultimap_HHAMT_Specialized(cmp, rootNode, hashCode, cachedSize); + } + } + + private abstract static class DataLayoutHelper extends CompactSetMultimapNode { + + private static final long[] arrayOffsets = + arrayOffsets(DataLayoutHelper.class, new String[]{"slot0", "slot1"}); + + public final Object slot0 = null; + + public final Object slot1 = null; + + private DataLayoutHelper() { + super(null, 0L); + } + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specialized_Interlinked.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specialized_Interlinked.java new file mode 100644 index 0000000..8c8cc68 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specialized_Interlinked.java @@ -0,0 +1,4285 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.multimap; + +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Deque; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import io.usethesource.capsule.SetMultimap; +import io.usethesource.capsule.core.PersistentTrieSet.AbstractSetNode; +import io.usethesource.capsule.core.PersistentTrieSet.SetResult; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Interlinked.SetMultimap0To0Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Interlinked.SetMultimap0To1Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Interlinked.SetMultimap0To2Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Interlinked.SetMultimap0To4Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Interlinked.SetMultimap1To0Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Interlinked.SetMultimap1To2Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Interlinked.SetMultimap2To0Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized_Interlinked.EitherSingletonOrCollection.Type; +import io.usethesource.capsule.util.EqualityComparator; +import io.usethesource.capsule.util.RangecopyUtils; +import io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap; + +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_DATA_COLLECTION; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_DATA_SINGLETON; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_EMPTY; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_NODE; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setBitPattern; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setFromNode; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setNodeOf; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setOf; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setToNode; +import static io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized_Interlinked.EitherSingletonOrCollection.Type.COLLECTION; +import static io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized_Interlinked.EitherSingletonOrCollection.Type.SINGLETON; +import static io.usethesource.capsule.util.BitmapUtils.filter; +import static io.usethesource.capsule.util.BitmapUtils.index; +import static io.usethesource.capsule.util.DataLayoutHelper.addressSize; +import static io.usethesource.capsule.util.DataLayoutHelper.arrayOffsets; +import static io.usethesource.capsule.util.DataLayoutHelper.fieldOffset; +import static io.usethesource.capsule.util.DataLayoutHelper.unsafe; +import static io.usethesource.capsule.util.RangecopyUtils._do_rangecompareObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.getFromObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.getFromObjectRegionAndCast; +import static io.usethesource.capsule.util.RangecopyUtils.rangecopyObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.setInObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.setInObjectRegionVarArgs; +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +public class TrieSetMultimap_HHAMT_Specialized_Interlinked + implements SetMultimap.Immutable { + + private final EqualityComparator cmp; + + protected static final CompactSetMultimapNode EMPTY_NODE = new SetMultimap0To0Node<>(null, 0L); + + private static final TrieSetMultimap_HHAMT_Specialized_Interlinked EMPTY_SETMULTIMAP = + new TrieSetMultimap_HHAMT_Specialized_Interlinked(EqualityComparator.EQUALS, EMPTY_NODE, 0, + 0); + + private static final boolean DEBUG = false; + + private final AbstractSetMultimapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieSetMultimap_HHAMT_Specialized_Interlinked(EqualityComparator cmp, + AbstractSetMultimapNode rootNode, int hashCode, int cachedSize) { + this.cmp = cmp; + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final SetMultimap.Immutable of() { + return TrieSetMultimap_HHAMT_Specialized_Interlinked.EMPTY_SETMULTIMAP; + } + + public static final SetMultimap.Immutable of(EqualityComparator cmp) { + // TODO: unify with `of()` + return new TrieSetMultimap_HHAMT_Specialized_Interlinked(cmp, EMPTY_NODE, 0, 0); + } + + public static final SetMultimap.Immutable of(K key, V... values) { + SetMultimap.Immutable result = + TrieSetMultimap_HHAMT_Specialized_Interlinked.EMPTY_SETMULTIMAP; + + for (V value : values) { + result = result.__insert(key, value); + } + + return result; + } + + public static final SetMultimap.Transient transientOf() { + return TrieSetMultimap_HHAMT_Specialized_Interlinked.EMPTY_SETMULTIMAP.asTransient(); + } + + public static final SetMultimap.Transient transientOf(K key, V... values) { + final SetMultimap.Transient result = + TrieSetMultimap_HHAMT_Specialized_Interlinked.EMPTY_SETMULTIMAP.asTransient(); + + for (V value : values) { + result.__insert(key, value); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.equals(iterator.next(), o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + return rootNode.containsTuple(key, val, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return setFromNode(result.get()); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public SetMultimap.Immutable __put(K key, V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieSetMultimap_HHAMT_Specialized_Interlinked(cmp, newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + final int valHashNew = val.hashCode(); + + return new TrieSetMultimap_HHAMT_Specialized_Interlinked(cmp, newRootNode, + hashCode + ((keyHash ^ valHashNew)) - sumOfReplacedHashes, + cachedSize - details.getReplacedCollection().size() + 1); + } + } + + final int valHash = val.hashCode(); + return new TrieSetMultimap_HHAMT_Specialized_Interlinked(cmp, newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable __insert(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + final int valHash = val.hashCode(); + return new TrieSetMultimap_HHAMT_Specialized_Interlinked(cmp, newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable union( + final SetMultimap setMultimap) { + final SetMultimap.Transient tmpTransient = this.asTransient(); + tmpTransient.union(setMultimap); + return tmpTransient.freeze(); + } + + @Override + public SetMultimap.Immutable __remove(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap_HHAMT_Specialized_Interlinked(cmp, newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable __remove(K key) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removedAll(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap_HHAMT_Specialized_Interlinked(cmp, newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + return new TrieSetMultimap_HHAMT_Specialized_Interlinked(cmp, newRootNode, + hashCode - sumOfReplacedHashes, cachedSize - details.getReplacedCollection().size()); + } + } + + return this; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new SetMultimapKeyIteratorLowLevel<>(rootNode); + // return new SetMultimapKeyIteratorHistogram<>(rootNode); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(AbstractSetNode::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + // return new SetMultimapTupleIterator<>(rootNode, AbstractSpecialisedImmutableMap::entryOf); + + return new FlatteningIterator<>(nativeEntryIterator()); + } + + @Override + public Iterator> nativeEntryIterator() { + return new SetMultimapNativeTupleIteratorLowLevel<>(rootNode); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new SetMultimapTupleIterator<>(rootNode, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieSetMultimap_HHAMT_Specialized_Interlinked.this.keyIterator(); + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT_Specialized_Interlinked.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT_Specialized_Interlinked.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieSetMultimap_HHAMT_Specialized_Interlinked.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieSetMultimap_HHAMT_Specialized_Interlinked.this.valueIterator(); + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT_Specialized_Interlinked.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT_Specialized_Interlinked.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TrieSetMultimap_HHAMT_Specialized_Interlinked.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT_Specialized_Interlinked.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT_Specialized_Interlinked.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieSetMultimap_HHAMT_Specialized_Interlinked.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieSetMultimap_HHAMT_Specialized_Interlinked) { + TrieSetMultimap_HHAMT_Specialized_Interlinked that = + (TrieSetMultimap_HHAMT_Specialized_Interlinked) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + final AbstractSetNode valColl = (AbstractSetNode) entry.getValue(); + + if (!cmp.equals(result.get(), valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public SetMultimap.Transient asTransient() { + return new TransientTrieSetMultimap_BleedingEdge(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractSetMultimapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieSetMultimap_BleedingEdgeNodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + // /* + // * For analysis purposes only. Payload X Node + // */ + // protected int[][] arityCombinationsHistogram() { + // final Iterator> it = nodeIterator(); + // final int[][] sumArityCombinations = new int[33][33]; + // + // while (it.hasNext()) { + // final AbstractSetMultimapNode node = it.next(); + // sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + // } + // + // return sumArityCombinations; + // } + // + // /* + // * For analysis purposes only. + // */ + // protected int[] arityHistogram() { + // final int[][] sumArityCombinations = arityCombinationsHistogram(); + // final int[] sumArity = new int[33]; + // + // final int maxArity = 32; // TODO: factor out constant + // + // for (int j = 0; j <= maxArity; j++) { + // for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + // sumArity[j + k] += sumArityCombinations[j][k]; + // } + // } + // + // return sumArity; + // } + // + // /* + // * For analysis purposes only. + // */ + // public void printStatistics() { + // final int[][] sumArityCombinations = arityCombinationsHistogram(); + // final int[] sumArity = arityHistogram(); + // final int sumNodes = getNodeCount(); + // + // final int[] cumsumArity = new int[33]; + // for (int cumsum = 0, i = 0; i < 33; i++) { + // cumsum += sumArity[i]; + // cumsumArity[i] = cumsum; + // } + // + // final float threshhold = 0.01f; // for printing results + // for (int i = 0; i < 33; i++) { + // float arityPercentage = (float) (sumArity[i]) / sumNodes; + // float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + // + // if (arityPercentage != 0 && arityPercentage >= threshhold) { + // // details per level + // StringBuilder bldr = new StringBuilder(); + // int max = i; + // for (int j = 0; j <= max; j++) { + // for (int k = max - j; k <= max - j; k++) { + // float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + // + // if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + // bldr.append(String.format("%d/%d: %s, ", j, k, + // new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + // } + // } + // } + // final String detailPercentages = bldr.toString(); + // + // // overview + // System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + // new DecimalFormat("0.00%").format(arityPercentage), + // new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + // } + // } + // } + + static abstract class EitherSingletonOrCollection { + + public enum Type { + SINGLETON, COLLECTION + } + + public static final EitherSingletonOrCollection of(T value) { + return new SomeSingleton<>(value); + } + + public static final EitherSingletonOrCollection of(AbstractSetNode value) { + return new SomeCollection<>(value); + } + + abstract boolean isType(Type type); + + abstract T getSingleton(); + + abstract AbstractSetNode getCollection(); + } + + static final class SomeSingleton extends EitherSingletonOrCollection { + + private final T value; + + private SomeSingleton(T value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.SINGLETON; + } + + @Override + T getSingleton() { + return value; + } + + @Override + AbstractSetNode getCollection() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.COLLECTION, Type.SINGLETON)); + } + } + + static final class SomeCollection extends EitherSingletonOrCollection { + + private final AbstractSetNode value; + + private SomeCollection(AbstractSetNode value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.COLLECTION; + } + + @Override + T getSingleton() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.SINGLETON, Type.COLLECTION)); + } + + @Override + AbstractSetNode getCollection() { + return value; + } + } + + static final class SetMultimapResult { + + private V replacedValue; + private AbstractSetNode replacedValueCollection; + private EitherSingletonOrCollection.Type replacedType; + + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(V replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + this.replacedType = SINGLETON; + } + + public void updated(AbstractSetNode replacedValueCollection) { + this.replacedValueCollection = replacedValueCollection; + this.isModified = true; + this.isReplaced = true; + this.replacedType = COLLECTION; + } + + // update: neither element, nor element count changed + public static SetMultimapResult unchanged() { + return new SetMultimapResult<>(); + } + + private SetMultimapResult() { + } + + public boolean isModified() { + return isModified; + } + + public EitherSingletonOrCollection.Type getType() { + return replacedType; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public V getReplacedValue() { + assert getType() == SINGLETON; + return replacedValue; + } + + public AbstractSetNode getReplacedCollection() { + assert getType() == COLLECTION; + return replacedValueCollection; + } + } + + protected static interface INode { + + } + + protected static abstract class AbstractSetMultimapNode implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract boolean containsTuple(final K key, final V val, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract Optional> findByKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract CompactSetMultimapNode inserted(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode updated(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode removed(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode removedAll(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractSetMultimapNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractSetMultimapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractSetMultimapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract int emptyArity(); + + // @Deprecated // split data / coll arity + abstract boolean hasPayload(); + + // + // @Deprecated // split data / coll arity + abstract int payloadArity(); + + abstract boolean hasPayload(EitherSingletonOrCollection.Type type); + + // abstract int payloadArity(); + + abstract int payloadArity(EitherSingletonOrCollection.Type type); + + abstract K getSingletonKey(final int index); + + abstract V getSingletonValue(final int index); + + abstract K getCollectionKey(final int index); + + abstract AbstractSetNode getCollectionValue(final int index); + + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + abstract int arity(); + + abstract int[] arities(); + + int size() { + final Iterator it = new SetMultimapKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactSetMultimapNode + extends AbstractSetMultimapNode { + + private long bitmap; + + private int cachedSlotArity; + private int cachedNodeArity; + private int cachedEmptyArity; + + @Deprecated + final void initializeLazyFields() { + // NOTE: temporariliy used to test caching of attributes; will be removed soon again + + // cachedSlotArity = (int) staticSlotArity(); + // cachedNodeArity = (int) Long.bitCount(filter(bitmap, PATTERN_NODE)); + // cachedEmptyArity = (int) Long.bitCount(filter(bitmap, PATTERN_EMPTY)); + } + + CompactSetMultimapNode(final AtomicReference mutator, final long bitmap) { + this.bitmap = bitmap; + initializeLazyFields(); + } + + final long bitmap() { + return bitmap; + } + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + static final int doubledMask(int keyHash, int shift) { + final int mask = mask(keyHash, shift); + return mask << 1; + } + + static final long doubledBitpos(final int doubledMask) { + return 1L << doubledMask; + } + + static final int pattern(long bitmap, int doubledMask) { + return (int) ((bitmap >>> doubledMask) & 0b11); + } + + static final long initializeArrayBase() { + try { + // assuems that both are of type Object and next to each other in memory + return DataLayoutHelper.arrayOffsets[0]; + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + static final long arrayBase = initializeArrayBase(); + + // static final Class[][] initializeSpecializationsByContentAndNodes() { + // Class[][] next = new Class[33][65]; + // + // try { + // for (int m = 0; m <= 32; m++) { + // for (int n = 0; n <= 64; n++) { + // int mNext = m; + // int nNext = n; + // + // // TODO: last expression is not properly generated yet and maybe incorrect + // if (mNext < 0 || mNext > 32 || nNext < 0 || nNext > 64 + // || Math.ceil(nNext / 2.0) + mNext > 32) { + // next[m][n] = null; + // } else { + // next[m][n] = Class.forName(String.format( + // "io.usethesource.capsule.TrieSetMultimap_HHAMT_Specializations_Path_Interlinked$SetMultimap%dTo%dNode", + // mNext, nNext)); + // } + // } + // } + // } catch (ClassNotFoundException e) { + // throw new RuntimeException(e); + // } + // + // return next; + // } + // + // static final Class[][] specializationsByContentAndNodes = + // initializeSpecializationsByContentAndNodes(); + + static final Class[] initializeSpecializationsByContentAndNodes() { + Class[] next = new Class[33 * 65]; + + try { + for (int m = 0; m <= 32; m++) { + for (int n = 0; n <= 64; n++) { + int mNext = m; + int nNext = n; + + // TODO: last expression is not properly generated yet and maybe incorrect + if (mNext < 0 || mNext > 32 || nNext < 0 || nNext > 64 + || Math.ceil(nNext / 2.0) + mNext > 32) { + next[65 * m + n] = null; + } else { + next[65 * m + n] = Class.forName(String.format( + "io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Interlinked$SetMultimap%dTo%dNode", + mNext, nNext)); + } + } + } + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } + + return next; + } + + static final Class[] specializationsByContentAndNodes = + initializeSpecializationsByContentAndNodes(); + + static final T allocateHeapRegion(final Class[] lookupTable, final int dim1, + final int dim2) { + final Class clazz = lookupTable[65 * dim1 + dim2]; + return RangecopyUtils.allocateHeapRegion(clazz); + } + + // static final byte[] initializeMetadataByContentAndNodes() { + // byte[] next = new byte[33 * 65 * 4]; + // + // try { + // for (int m = 0; m <= 32; m++) { + // for (int n = 0; n <= 64; n++) { + // int mNext = m; + // int nNext = n; + // + // // TODO: last expression is not properly generated yet and maybe incorrect + // if (mNext < 0 || mNext > 32 || nNext < 0 || nNext > 64 + // || Math.ceil(nNext / 2.0) + mNext > 32) { + //// int section = (65 * m + n) * 4; + //// next[65 * m + n] = 0; + // } else { + // Class clazz = Class.forName(String.format( + // "io.usethesource.capsule.TrieSetMultimap_HHAMT_Specializations_Path_Interlinked$SetMultimap%dTo%dNode", + // mNext, nNext)); + // + // int section = (65 * m + n) * 4; + // next[section + 0] = (byte) unsafe.getLong(clazz, globalRareBaseOffset); + // next[section + 1] = (byte) unsafe.getInt(clazz, globalPayloadArityOffset); + // next[section + 2] = (byte) unsafe.getInt(clazz, globalUntypedSlotArityOffset); + // next[section + 3] = (byte) unsafe.getInt(clazz, globalSlotArityOffset); + // + // if (next[section + 0] < 0) + // System.out.println(next[section + 0]); + // } + // } + // } + // } catch (ClassNotFoundException e) { + // throw new RuntimeException(e); + // } + // + // return next; + // } + // + // static final byte[] metadataByContentAndNodes = + // initializeMetadataByContentAndNodes(); + + static long globalRawMap1Offset = fieldOffset(SetMultimap0To2Node.class, "rawMap1"); + + static long globalRawMap2Offset = fieldOffset(SetMultimap0To2Node.class, "rawMap2"); + + static long globalArrayOffsetsOffset = fieldOffset(SetMultimap0To2Node.class, "arrayOffsets"); + + static long globalNodeArityOffset = fieldOffset(SetMultimap0To2Node.class, "nodeArity"); + + static long globalPayloadArityOffset = fieldOffset(SetMultimap0To2Node.class, "payloadArity"); + + static long globalSlotArityOffset = fieldOffset(SetMultimap0To2Node.class, "slotArity"); + + static long globalUntypedSlotArityOffset = + fieldOffset(SetMultimap0To2Node.class, "untypedSlotArity"); + + static long globalRareBaseOffset = fieldOffset(SetMultimap0To2Node.class, "rareBase"); + + static long globalArrayOffsetLastOffset = + fieldOffset(SetMultimap0To2Node.class, "arrayOffsetLast"); + + static long globalNodeBaseOffset = fieldOffset(SetMultimap0To2Node.class, "nodeBase"); + + private final long staticRareBase() { + return unsafe.getLong(this.getClass(), globalRareBaseOffset); + } + + private final int staticSlotArity() { + return unsafe.getInt(this.getClass(), globalSlotArityOffset); + } + + private final int staticUntypedSlotArity() { + return unsafe.getInt(this.getClass(), globalUntypedSlotArityOffset); + } + + private final int staticPayloadArity() { + return unsafe.getInt(this.getClass(), globalPayloadArityOffset); + } + + // @Deprecated + // abstract int dataMap(); + // + // @Deprecated + // abstract int collMap(); + // + // @Deprecated + // abstract int nodeMap(); + + // TODO: remove final modifier when collision node does not depend on compact node anymore + @Override + boolean hasPayload() { + return payloadArity() != 0; + } + + // TODO: remove final modifier when collision node does not depend on compact node anymore + @Override + int payloadArity() { + return 32 - nodeArity() - emptyArity(); + } + + // TODO: remove final modifier when collision node does not depend on compact node anymore + @Override + boolean hasPayload(EitherSingletonOrCollection.Type type) { + return payloadArity(type) != 0; + } + + // TODO: remove final modifier when collision node does not depend on compact node anymore + @Override + int payloadArity(EitherSingletonOrCollection.Type type) { + if (type == Type.SINGLETON) { + return arity(bitmap(), PATTERN_DATA_SINGLETON); + } else { + return arity(bitmap(), PATTERN_DATA_COLLECTION); + } + } + + // TODO: remove final modifier when collision node does not depend on compact node anymore + @Override + K getSingletonKey(final int index) { + return (K) getFromObjectRegion(this, arrayBase, TUPLE_LENGTH * index); + } + + // TODO: remove final modifier when collision node does not depend on compact node anymore + @Override + V getSingletonValue(final int index) { + return (V) getFromObjectRegion(this, arrayBase, TUPLE_LENGTH * index + 1); + } + + // TODO: remove final modifier when collision node does not depend on compact node anymore + @Override + K getCollectionKey(final int index) { + return (K) getFromObjectRegion(this, staticRareBase(), TUPLE_LENGTH * index); + } + + // TODO: remove final modifier when collision node does not depend on compact node anymore + @Override + AbstractSetNode getCollectionValue(final int index) { + return (AbstractSetNode) getFromObjectRegion(this, staticRareBase(), + TUPLE_LENGTH * index + 1); + } + + // TODO: remove final modifier when collision node does not depend on compact node anymore + @Override + boolean hasSlots() { + return slotArity() != 0; + } + + // TODO: remove final modifier when collision node does not depend on compact node anymore + @Override + int slotArity() { + return staticSlotArity(); + + // return cachedSlotArity; + } + + // TODO: remove final modifier when collision node does not depend on compact node anymore + @Override + Object getSlot(final int index) { + return getFromObjectRegion(this, arrayBase, index); + } + + @Override + final int emptyArity() { + return Long.bitCount(filter(bitmap, PATTERN_EMPTY)); + // return arity(bitmap, PATTERN_EMPTY); + + // return cachedEmptyArity; + } + + @Deprecated + @Override + int arity() { + // TODO: replace with 32 - arity(emptyMap) + // return arity(bitmap(), PATTERN_DATA_SINGLETON) + arity(bitmap(), PATTERN_DATA_COLLECTION) + + // arity(bitmap(), PATTERN_NODE); + + int[] arities = arities(bitmap()); + return Arrays.stream(arities).skip(1).sum(); + } + + static final int arity(long bitmap, int pattern) { + // if (bitmap == 0) { + // if (pattern == PATTERN_EMPTY) { + // return 32; + // } else { + // return 0; + // } + // } else { + // return Long.bitCount(filter(bitmap, pattern)); + // } + + long filteredBitmap = filter(bitmap, pattern); + + // if (filteredBitmap == 0) { + // if (pattern == PATTERN_EMPTY) { + // return 32; + // } else { + // return 0; + // } + // } + + return Long.bitCount(filteredBitmap); + } + + @Override + public final int[] arities() { + return arities(bitmap); + } + + static final int[] arities(final long bitmap) { + int[] arities = new int[4]; + + arities[0] = Long.bitCount(filter(bitmap, PATTERN_EMPTY)); + arities[1] = Long.bitCount(filter(bitmap, PATTERN_DATA_SINGLETON)); + arities[2] = Long.bitCount(filter(bitmap, PATTERN_DATA_COLLECTION)); + arities[3] = Long.bitCount(filter(bitmap, PATTERN_NODE)); + + return arities; + } + + static final int[] aritiesSingleLoopOverLong(final long bitmap) { + int[] arities = new int[4]; + + long shiftedBitmap = bitmap; + for (int i = 0; i < 32; i++) { + arities[(int) shiftedBitmap & 0b11]++; + shiftedBitmap = shiftedBitmap >>> 2; + } + + return arities; + } + + static final int[] aritiesDoubleLoopOverInt(final long bitmap) { + int[] arities = new int[4]; + + int segment0 = (int) (bitmap >>> 32); + int segment1 = (int) (bitmap); + + for (int i = 0; i < 16; i++) { + arities[segment0 & 0b11]++; + segment0 = segment0 >>> 2; + } + + for (int i = 0; i < 16; i++) { + arities[segment1 & 0b11]++; + segment1 = segment1 >>> 2; + } + + return arities; + } + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + byte sizePredicate() { + final long bitmap = this.bitmap(); + + int nodeArity = arity(bitmap, PATTERN_NODE); + int emptyArity = arity(bitmap, PATTERN_EMPTY); + + if (nodeArity > 0) { + return SIZE_MORE_THAN_ONE; + } else { + switch (emptyArity) { + case 32: + return SIZE_EMPTY; + case 31: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } + } + + @Override + boolean hasNodes() { + return nodeArity() != 0; + } + + // TODO: add final modifier when collision node does not depend on compact node anymore + @Override + int nodeArity() { + return Long.bitCount(filter(bitmap, PATTERN_NODE)); + // return arity(bitmap, PATTERN_NODE); + + // return cachedNodeArity; + } + + // TODO: remove final modifier when collision node does not depend on compact node anymore + @Override + CompactSetMultimapNode getNode(final int index) { + final int pIndex = slotArity() - 1 - index; + + return (CompactSetMultimapNode) getSlot(pIndex); + + // final long rareBase = staticRareBase(); + // + // final int untypedSlotArity = staticUntypedSlotArity(); + // final int pIndex = untypedSlotArity - 1 - index; + // + // return (CompactSetMultimapNode) getFromObjectRegion(this, rareBase, pIndex); + } + + void assertNodeInvariant() { + // return true; + // boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + // boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + // boolean inv3 = + // (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + // boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + // + // boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + // && ((this.payloadArity() + this.nodeArity()) == this.arity()); + // + // return inv1 && inv2 && inv3 && inv4 && inv5; + + // if (DEBUG) { + int[] arities = arities(bitmap); + + assert (TUPLE_LENGTH * arities[PATTERN_DATA_SINGLETON] + + TUPLE_LENGTH * arities[PATTERN_DATA_COLLECTION] + arities[PATTERN_NODE] == slotArity()); + + for (int i = 0; i < arities[PATTERN_DATA_SINGLETON]; i++) { + int offset = i * TUPLE_LENGTH; + + assert ((getSlot(offset + 0) instanceof io.usethesource.capsule.Set.Immutable) + == false); + assert ((getSlot(offset + 1) instanceof io.usethesource.capsule.Set.Immutable) + == false); + + assert ((getSlot(offset + 0) instanceof CompactSetMultimapNode) == false); + assert ((getSlot(offset + 1) instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arities[PATTERN_DATA_COLLECTION]; i++) { + int offset = (i + arities[PATTERN_DATA_SINGLETON]) * TUPLE_LENGTH; + + assert ((getSlot(offset + 0) instanceof io.usethesource.capsule.Set.Immutable) + == false); + assert ((getSlot(offset + 1) instanceof io.usethesource.capsule.Set.Immutable) == true); + + assert ((getSlot(offset + 0) instanceof CompactSetMultimapNode) == false); + assert ((getSlot(offset + 1) instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arities[PATTERN_NODE]; i++) { + int offset = + (arities[PATTERN_DATA_SINGLETON] + arities[PATTERN_DATA_COLLECTION]) * TUPLE_LENGTH; + + assert ((getSlot(offset + i) instanceof io.usethesource.capsule.Set.Immutable) + == false); + + assert ((getSlot(offset + i) instanceof CompactSetMultimapNode) == true); + } + } + // } + + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + final long updatedBitmap) { + final Class srcClass = this.getClass(); + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = RangecopyUtils.allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.bitmap = updatedBitmap; + + rangecopyObjectRegion(src, dst, arrayBase, staticSlotArity()); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndSetSingletonValue(final AtomicReference mutator, + final long doubledBitpos, final V val) { + final int index = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = RangecopyUtils.allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.bitmap = bitmap; + + final int slotArity = staticSlotArity(); + int pIndex = TUPLE_LENGTH * index + 1; + + rangecopyObjectRegion(src, arrayBase, dst, arrayBase, slotArity); + setInObjectRegion(dst, arrayBase, pIndex, val); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndSetCollectionValue(final AtomicReference mutator, + final long doubledBitpos, final AbstractSetNode valColl) { + final int index = collIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = RangecopyUtils.allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.bitmap = bitmap; + + final int slotArity = staticSlotArity(); + int pIndex = TUPLE_LENGTH * index + 1; + + rangecopyObjectRegion(src, arrayBase, dst, arrayBase, slotArity); + setInObjectRegion(dst, staticRareBase(), pIndex, valColl); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + static final CompactSetMultimapNode allocateHeapRegionAndSetBitmap( + final Class clazz, final long bitmap) { + try { + final CompactSetMultimapNode newInstance = + (CompactSetMultimapNode) unsafe.allocateInstance(clazz); + newInstance.bitmap = bitmap; + return newInstance; + } catch (ClassCastException | InstantiationException e) { + throw new RuntimeException(e); + } + } + + CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final int index, final CompactSetMultimapNode node) { + final Class srcClass = this.getClass(); + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = RangecopyUtils.allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.bitmap = bitmap; + + final int slotArity = staticSlotArity(); + final int pIndex = slotArity - 1 - index; + + // single copy spanning over all references + rangecopyObjectRegion(src, dst, arrayBase, slotArity); + setInObjectRegion(dst, arrayBase, pIndex, node); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndInsertSingleton(final AtomicReference mutator, + final long doubledBitpos, final K key, final V val) { + final int index = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = + allocateHeapRegion(specializationsByContentAndNodes, payloadArity + 1, untypedSlotArity); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_SINGLETON); + + final int pIndex = TUPLE_LENGTH * index; + + long offset = arrayBase; + long delta = 0; + + offset += rangecopyObjectRegion(src, dst, offset, pIndex); + delta += setInObjectRegionVarArgs(dst, offset, key, val); + offset += rangecopyObjectRegion(src, offset, dst, offset + delta, slotArity - pIndex); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + final AtomicReference mutator, final long doubledBitpos, final int indexOld, + final K key, final AbstractSetNode valColl) { + // final int indexOld = dataIndex(doubledBitpos); + final int indexNew = collIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity - 1, untypedSlotArity + 2); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_COLLECTION); + + final int pIndexOld = TUPLE_LENGTH * indexOld; + final int pIndexNew = TUPLE_LENGTH * (payloadArity - 1 + indexNew); + + /* TODO: test code below; not sure that length arguments are correct */ + + long offset = arrayBase; + long delta2 = addressSize * 2; + + offset += rangecopyObjectRegion(src, dst, offset, pIndexOld); + offset += rangecopyObjectRegion(src, offset + delta2, dst, offset, pIndexNew - pIndexOld); + setInObjectRegionVarArgs(dst, offset, key, valColl); + offset += rangecopyObjectRegion(src, dst, offset + delta2, slotArity - pIndexNew - 2); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndRemoveSingleton(final AtomicReference mutator, + final long doubledBitpos) { + final int indexOld = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + if (payloadArity == 1 && untypedSlotArity == 0) { + // TODO: check if this optimization can be performed in caller + return EMPTY_NODE; + } else { + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity - 1, untypedSlotArity); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_EMPTY); + + final int pIndexOld = TUPLE_LENGTH * indexOld; + + long offset = arrayBase; + offset += rangecopyObjectRegion(src, dst, offset, pIndexOld); + long delta = 2 * addressSize /* sizeOfInt() */; + offset += rangecopyObjectRegion(src, offset + delta, dst, offset, + (TUPLE_LENGTH * (payloadArity - 1) - pIndexOld + untypedSlotArity)); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + } + + /* + * Batch updated, necessary for removedAll. + */ + CompactSetMultimapNode copyAndRemoveCollection(final AtomicReference mutator, + final long doubledBitpos) { + final int indexOld = collIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + if (payloadArity == 0 && untypedSlotArity == TUPLE_LENGTH) { + // TODO: check if this optimization can be performed in caller + return EMPTY_NODE; + } else { + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity, untypedSlotArity - TUPLE_LENGTH); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_EMPTY); + + final int pIndexOld = TUPLE_LENGTH * (payloadArity + indexOld); + + long offset = arrayBase; + offset += rangecopyObjectRegion(src, dst, offset, pIndexOld); + long delta = 2 * addressSize /* sizeOfInt() */; + offset += rangecopyObjectRegion(src, offset + delta, dst, offset, + (TUPLE_LENGTH * (payloadArity - 1) - pIndexOld + untypedSlotArity)); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + } + + CompactSetMultimapNode copyAndMigrateFromSingletonToNode( + final AtomicReference mutator, final long doubledBitpos, final int indexOld, + final CompactSetMultimapNode node) { + // final int indexOld = dataIndex(doubledBitpos); + final int indexNew = nodeIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity - 1, untypedSlotArity + 1); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_NODE); + + final int pIndexOld = TUPLE_LENGTH * indexOld; + final int pIndexNew = (slotArity - 1) - 1 - indexNew; + + copyAndMigrateFromXxxToNode(src, dst, slotArity, pIndexOld, pIndexNew, node); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + private void copyAndMigrateFromXxxToNode(final CompactSetMultimapNode src, + final CompactSetMultimapNode dst, final int slotArity, final int pIndexOld, + final int pIndexNew, final CompactSetMultimapNode node) { + long offset = arrayBase; + long delta1 = addressSize; + long delta2 = 2 * addressSize; + + offset += rangecopyObjectRegion(src, dst, offset, pIndexOld); + offset += rangecopyObjectRegion(src, offset + delta2, dst, offset, pIndexNew - pIndexOld); + + setInObjectRegionVarArgs(dst, offset, node); + + offset += rangecopyObjectRegion(src, offset + delta2, dst, offset + delta1, + slotArity - pIndexNew - 2); + } + + CompactSetMultimapNode copyAndMigrateFromCollectionToNode( + final AtomicReference mutator, final long doubledBitpos, final int indexOld, + final CompactSetMultimapNode node) { + // final int indexOld = collIndex(doubledBitpos); + final int indexNew = nodeIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity, untypedSlotArity - TUPLE_LENGTH + 1); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_NODE); + + final int pIndexOld = TUPLE_LENGTH * (payloadArity + indexOld); + final int pIndexNew = (slotArity - 1) - 1 - indexNew; + + copyAndMigrateFromXxxToNode(src, dst, slotArity, pIndexOld, pIndexNew, node); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node) { // node get's unwrapped inside method + + final int indexOld = nodeIndex(doubledBitpos); + final int indexNew = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity + 1, untypedSlotArity - 1); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_SINGLETON); + + final int pIndexOld = slotArity - 1 - indexOld; + final int pIndexNew = TUPLE_LENGTH * indexNew; + + Object keyToInline = node.getSingletonKey(0); + Object valToInline = node.getSingletonValue(0); + + copyAndMigrateFromNodeToXxx(src, dst, slotArity, pIndexOld, pIndexNew, keyToInline, + valToInline); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndMigrateFromNodeToCollection( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node) { // node get's unwrapped inside method + + final int indexOld = nodeIndex(doubledBitpos); + final int indexNew = collIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity, untypedSlotArity - 1 + TUPLE_LENGTH); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_COLLECTION); + + final int pIndexOld = slotArity - 1 - indexOld; + final int pIndexNew = TUPLE_LENGTH * indexNew; + + Object keyToInline = node.getCollectionKey(0); + Object valToInline = node.getCollectionValue(0); + + copyAndMigrateFromNodeToXxx(src, dst, slotArity, pIndexOld, pIndexNew, keyToInline, + valToInline); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + private void copyAndMigrateFromNodeToXxx(final CompactSetMultimapNode src, + final CompactSetMultimapNode dst, final int slotArity, final int pIndexOld, + final int pIndexNew, Object keyToInline, Object valToInline) { + long offset = arrayBase; + long delta1 = addressSize; + long delta2 = delta1 * 2; + + offset += rangecopyObjectRegion(src, dst, offset, pIndexNew); + setInObjectRegionVarArgs(dst, offset, keyToInline, valToInline); + offset += rangecopyObjectRegion(src, offset, dst, offset + delta2, pIndexOld - pIndexNew); + offset += rangecopyObjectRegion(src, offset + delta1, dst, offset + delta2, + slotArity - pIndexOld - 1); + } + + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + final AtomicReference mutator, final long doubledBitpos, final K key, final V val) { + + // TODO: does not support src == dst yet for shifting + + final int indexOld = collIndex(doubledBitpos); + final int indexNew = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity + 1, untypedSlotArity - 2); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_SINGLETON); + + final int pIndexOld = TUPLE_LENGTH * (payloadArity + indexOld); + final int pIndexNew = TUPLE_LENGTH * indexNew; + + long offset = arrayBase; + long delta2 = addressSize * 2; + + offset += rangecopyObjectRegion(src, dst, offset, pIndexNew); + setInObjectRegionVarArgs(dst, offset, key, val); + offset += rangecopyObjectRegion(src, offset, dst, offset + delta2, pIndexOld - pIndexNew); + offset += rangecopyObjectRegion(src, dst, offset + delta2, slotArity - pIndexOld - 2); + + // dst.assertNodeInvariant(); + dst.initializeLazyFields(); + return dst; + } + + // TODO: fix hash collision support + static final CompactSetMultimapNode mergeTwoSingletonPairs(final K key0, + final V val0, final int keyHash0, final K key1, final V val1, final int keyHash1, + final int shift, EqualityComparator cmp) { + assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode.of(keyHash0, key0, setOf(val0), key1, setOf(val1)); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_SINGLETON); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_SINGLETON); + + if (mask0 < mask1) { + return nodeOf0x2(null, bitmap, key0, val0, key1, val1); + } else { + return nodeOf0x2(null, bitmap, key1, val1, key0, val0); + } + } else { + final CompactSetMultimapNode node = mergeTwoSingletonPairs(key0, val0, keyHash0, key1, + val1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf1x0(null, bitmap, node); + } + } + + // TODO: fix hash collision support + static final CompactSetMultimapNode mergeCollectionAndSingletonPairs(final K key0, + final AbstractSetNode valColl0, final int keyHash0, final K key1, final V val1, + final int keyHash1, final int shift, EqualityComparator cmp) { + assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode + .of(keyHash0, key0, setFromNode(valColl0), key1, setOf(val1)); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_COLLECTION); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_SINGLETON); + + // singleton before collection + return nodeOf2x1(null, bitmap, key1, val1, key0, valColl0); + } else { + final CompactSetMultimapNode node = mergeCollectionAndSingletonPairs(key0, valColl0, + keyHash0, key1, val1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf1x0(null, bitmap, node); + } + } + + // static final int index(final int bitmap, final int bitpos) { + // return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + // } + // + // static final int index(final int bitmap, final int mask, final int bitpos) { + // return (bitmap == -1) ? mask : index(bitmap, bitpos); + // } + + @Deprecated + int dataIndex(final long doubledBitpos) { + return index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + } + + @Deprecated + int collIndex(final long doubledBitpos) { + return index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + } + + @Deprecated + int nodeIndex(final long doubledBitpos) { + return index(bitmap, PATTERN_NODE, doubledBitpos); + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + return cmp.equals(getSingletonKey(index), key); + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + return cmp.equals(getCollectionKey(index), key); + } + default: + return false; + } + } + + @Override + boolean containsTuple(final K key, final V val, final int keyHash, final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + + final AbstractSetMultimapNode subNode = getNode(index); + return subNode.containsTuple(key, val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(index); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(index); + return cmp.equals(currentVal, val); + } + + return false; + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(index); + if (cmp.equals(currentKey, key)) { + + final AbstractSetNode currentValColl = getCollectionValue(index); + return currentValColl.contains(val, val.hashCode(), 0); + } + + return false; + } + default: + return false; + } + } + + @Override + Optional> findByKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + + final AbstractSetMultimapNode subNode = getNode(index); + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(index); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(index); + return Optional.of(setNodeOf(currentVal)); + } + + return Optional.empty(); + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(index); + if (cmp.equals(currentKey, key)) { + + final AbstractSetNode currentValColl = getCollectionValue(index); + return Optional.of(currentValColl); + } + + return Optional.empty(); + } + default: + return Optional.empty(); + } + } + + @Override + CompactSetMultimapNode inserted(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = subNode.inserted(mutator, key, val, + keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + if (cmp.equals(currentVal, val)) { + return this; + } else { + // migrate from singleton to collection + final AbstractSetNode valColl = setNodeOf(currentVal, val); + + details.modified(); + return copyAndMigrateFromSingletonToCollection(mutator, doubledBitpos, dataIndex, + currentKey, valColl); + } + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, dataIndex, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final AbstractSetNode currentCollVal = getCollectionValue(collIndex); + + if (currentCollVal.contains(val, val.hashCode(), 0)) { + return this; + } else { + // add new mapping + final AbstractSetNode newCollVal = + currentCollVal.updated(mutator, val, val.hashCode(), 0, SetResult.unchanged()); + + details.modified(); + return copyAndSetCollectionValue(mutator, doubledBitpos, newCollVal); + } + } else { + // prefix-collision (case: collection x singleton) + final AbstractSetNode currentValNode = getCollectionValue(collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, collIndex, + subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertSingleton(mutator, doubledBitpos, key, val); + } + } + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + // update singleton value + details.updated(currentVal); + return copyAndSetSingletonValue(mutator, doubledBitpos, val); + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, dataIndex, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final AbstractSetNode currentCollVal = getCollectionValue(collIndex); + + // migrate from collection to singleton + details.updated(currentCollVal); + return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, currentCollKey, + val); + } else { + // prefix-collision (case: collection x singleton) + final AbstractSetNode currentValNode = getCollectionValue(collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, collIndex, + subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertSingleton(mutator, doubledBitpos, key, val); + } + } + } + + @Override + CompactSetMultimapNode removed(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.removed(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (slotArity() == 0) { + if (shift == 0) { + // singleton remaining + final long doubledBitposAtShift0 = doubledBitpos(bitpos(doubledMask(keyHash, 0))); + + final long updatedBitmapAtShift0 = + setBitPattern(doubledBitposAtShift0, subNodeNew.patternOfSingleton()); + + return subNodeNew.copyAndUpdateBitmaps(mutator, updatedBitmapAtShift0); + } else { + // escalate (singleton or empty) result + return subNodeNew; + } + } else { + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + } + + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(dataIndex); + if (cmp.equals(currentVal, val)) { + + // remove mapping + details.updated(val); + return copyAndRemoveSingleton(mutator, doubledBitpos); + } else { + return this; + } + } else { + return this; + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(collIndex); + if (cmp.equals(currentKey, key)) { + + final AbstractSetNode currentValColl = getCollectionValue(collIndex); + if (currentValColl.contains(val, val.hashCode(), 0)) { + + // remove mapping + details.updated(val); + + final AbstractSetNode newValColl = + currentValColl.removed(mutator, val, val.hashCode(), 0, SetResult.unchanged()); + + if (newValColl.size() == 1) { + // TODO: investigate options for unboxing singleton collections + V remainingVal = newValColl.iterator().next(); + return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, key, + remainingVal); + } else { + return copyAndSetCollectionValue(mutator, doubledBitpos, newValColl); + } + } else { + return this; + } + } else { + return this; + } + } + default: + return this; + } + } + + final static boolean hasSingleNode(int[] arities) { + return arities[PATTERN_EMPTY] == 31 && arities[PATTERN_NODE] == 1; + } + + final static boolean hasTwoPayloads(int[] arities) { + return arities[PATTERN_EMPTY] == 30 && arities[PATTERN_NODE] == 0; + } + + enum State { + EMPTY, NODE, PAYLOAD, PAYLOAD_RARE + } + + static final State toState(final int pattern) { + // final State[] states = {State.EMPTY, State.NODE, State.PAYLOAD, State.PAYLOAD_RARE}; + // return states[pattern]; + + switch (pattern) { + case PATTERN_EMPTY: + return State.EMPTY; + case PATTERN_NODE: + return State.NODE; + case PATTERN_DATA_SINGLETON: + return State.PAYLOAD; + default: + return State.PAYLOAD_RARE; + } + } + + @Override + CompactSetMultimapNode removedAll(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.removedAll(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (slotArity() == 1) { + if (shift == 0) { + // singleton remaining + final long doubledBitposAtShift0 = doubledBitpos(bitpos(doubledMask(keyHash, 0))); + + final long updatedBitmapAtShift0 = + setBitPattern(doubledBitposAtShift0, subNodeNew.patternOfSingleton()); + + return subNodeNew.copyAndUpdateBitmaps(mutator, updatedBitmapAtShift0); + } else { + // escalate (singleton or empty) result + return subNodeNew; + } + } else { + // // inline value (move to front) + // final State subNodeState = subNodeNew.stateOfSingleton(); + // + //// switch (subNodeState) { + //// case EMPTY: + //// case NODE: + //// case PAYLOAD: + //// return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + //// case PAYLOAD_RARE: + //// return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + //// } + // + // if (subNodeState == State.PAYLOAD) { + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // } else { + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // } + + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + } + + // // inline value (move to front) + // final int subNodePattern = subNodeNew.patternOfSingleton(); + // + // if (subNodePattern == PATTERN_DATA_SINGLETON) { + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // } else { + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // } + + // switch (subNodePattern) { + // case PATTERN_DATA_SINGLETON: + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // case PATTERN_DATA_COLLECTION: + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // default: + // return null; + // } + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(dataIndex); + + details.updated(currentVal); + return copyAndRemoveSingleton(mutator, doubledBitpos); + } else { + return this; + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(collIndex); + if (cmp.equals(currentKey, key)) { + + final AbstractSetNode currentValColl = getCollectionValue(collIndex); + + details.updated(currentValColl); + return copyAndRemoveCollection(mutator, doubledBitpos); + } else { + return this; + } + } + default: + return this; + } + } + + int patternOfSingleton() { + assert this.sizePredicate() == SIZE_ONE; + + long bitmap = this.bitmap(); + + final int doubledMask = Long.numberOfTrailingZeros(bitmap) / 2 * 2; + final int pattern = pattern(bitmap, doubledMask); + + return pattern; + } + + @Deprecated + State stateOfSingleton() { + assert this.sizePredicate() == SIZE_ONE; + + long bitmap = this.bitmap(); + + final int doubledMask = Long.numberOfTrailingZeros(bitmap) / 2 * 2; + final int pattern = pattern(bitmap, doubledMask); + + return toState(pattern); + } + + @Deprecated + EitherSingletonOrCollection.Type typeOfSingleton() { + final int pattern = patternOfSingleton(); + + if (pattern == PATTERN_DATA_SINGLETON) { + return EitherSingletonOrCollection.Type.SINGLETON; + } else { + return EitherSingletonOrCollection.Type.COLLECTION; + } + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + long bitmap = this.bitmap(); + + int[] arities = arities(bitmap); + + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < arities[PATTERN_DATA_SINGLETON]; i++) { + final byte pos = -1; // TODO: recoverMask(dataMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getSingletonKey(i)), + Objects.hashCode(getSingletonValue(i)))); + + if (!((i + 1) == arities[PATTERN_DATA_SINGLETON])) { + bldr.append(", "); + } + } + + if (arities[PATTERN_DATA_SINGLETON] > 0 && arities[PATTERN_DATA_COLLECTION] > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arities[PATTERN_DATA_COLLECTION]; i++) { + final byte pos = -1; // TODO: recoverMask(collMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getCollectionKey(i)), + Objects.hashCode(getCollectionValue(i)))); + + if (!((i + 1) == arities[PATTERN_DATA_COLLECTION])) { + bldr.append(", "); + } + } + + if (arities[PATTERN_DATA_COLLECTION] > 0 && arities[PATTERN_NODE] > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arities[PATTERN_NODE]; i++) { + final byte pos = -1; // TODO: recoverMask(nodeMap, (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == arities[PATTERN_NODE])) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + CompactSetMultimapNode that = (CompactSetMultimapNode) other; + if (bitmap() != that.bitmap()) { + return false; + } + + return _do_rangecompareObjectRegion(this, that, arrayBase, slotArity()); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf1x0(final AtomicReference mutator, + final long bitmap, final Object slot0) { + return new SetMultimap0To1Node<>(mutator, bitmap, slot0); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf0x1(final AtomicReference mutator, + final long bitmap, final K key1, final V val1) { + return new SetMultimap1To0Node<>(mutator, bitmap, key1, val1); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf0x2(final AtomicReference mutator, + final long bitmap, final K key1, final V val1, final K key2, final V val2) { + return new SetMultimap2To0Node<>(mutator, bitmap, key1, val1, key2, val2); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf4x0(final AtomicReference mutator, + final long bitmap, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + return new SetMultimap0To4Node<>(mutator, bitmap, slot0, slot1, slot2, slot3); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf2x0(final AtomicReference mutator, + final long bitmap, final Object slot0, final Object slot1) { + return new SetMultimap0To2Node<>(mutator, bitmap, slot0, slot1); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf2x1(final AtomicReference mutator, + final long bitmap, final K key1, final V val1, final Object slot0, final Object slot1) { + return new SetMultimap1To2Node<>(mutator, bitmap, key1, val1, slot0, slot1); + } + + } + + private static abstract class AbstractHashCollisionNode + extends CompactSetMultimapNode { + + // TODO: remove constructor and stored properties within CompactSetMultimapNode + AbstractHashCollisionNode() { + super(null, 0L); + } + + static final > AbstractHashCollisionNode of( + final int hash, final K key0, final VS valColl0, final K key1, final VS valColl1) { + return new HashCollisionNode<>(hash, key0, valColl0, key1, valColl1); + } + + private static final RuntimeException UOE_BOILERPLATE = new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + private static final Supplier UOE_FACTORY = + () -> new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + @Override + CompactSetMultimapNode copyAndSetSingletonValue(AtomicReference mutator, + long doubledBitpos, V val) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndSetCollectionValue(AtomicReference mutator, + long doubledBitpos, AbstractSetNode valColl) { + throw UOE_FACTORY.get(); + } + +// @Override +// CompactSetMultimapNode copyAndSetNode(AtomicReference mutator, long doubledBitpos, +// CompactSetMultimapNode node) { +// throw UOE_FACTORY.get(); +// } + + @Override + CompactSetMultimapNode copyAndInsertSingleton(AtomicReference mutator, + long doubledBitpos, K key, V val) { + throw UOE_FACTORY.get(); + } + +// @Override +// CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( +// AtomicReference mutator, long doubledBitpos, K key, AbstractSetNode valColl) { +// throw UOE_FACTORY.get(); +// } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(AtomicReference mutator, + long doubledBitpos) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveCollection(AtomicReference mutator, + long doubledBitpos) { + throw UOE_FACTORY.get(); + } + +// @Override +// CompactSetMultimapNode copyAndMigrateFromSingletonToNode(AtomicReference mutator, +// long doubledBitpos, CompactSetMultimapNode node) { +// throw UOE_FACTORY.get(); +// } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + +// @Override +// CompactSetMultimapNode copyAndMigrateFromCollectionToNode(AtomicReference mutator, +// long doubledBitpos, CompactSetMultimapNode node) { +// throw UOE_FACTORY.get(); +// } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToCollection(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + long bitmap) { + throw UOE_FACTORY.get(); + } + +// @Override +// CompactSetMultimapNode copyAndInsertCollection(AtomicReference mutator, +// long doubledBitpos, K key, AbstractSetNode valColl) { +// throw UOE_FACTORY.get(); +// } + +// @Override +// CompactSetMultimapNode copyAndRemoveSingleton(AtomicReference mutator, +// long doubledBitpos, long updatedBitmap) { +// throw UOE_FACTORY.get(); +// } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + AtomicReference mutator, long doubledBitpos, K key, V val) { + throw UOE_FACTORY.get(); + } + +// @Override +// long bitmap() { +// throw UOE_FACTORY.get(); +// } +// +// @Override +// int emptyArity() { +// throw UOE_FACTORY.get(); +// } + + @Override + Type typeOfSingleton() { + throw UOE_FACTORY.get(); + } + + @Override + int patternOfSingleton() { + throw UOE_FACTORY.get(); + } + } + + private static final class HashCollisionNode extends AbstractHashCollisionNode { + + private final int hash; + private final List>> collisionContent; + + HashCollisionNode(final int hash, final K key0, + final io.usethesource.capsule.Set.Immutable valColl0, final K key1, + final io.usethesource.capsule.Set.Immutable valColl1) { + this(hash, Arrays.asList(entryOf(key0, valColl0), entryOf(key1, valColl1))); + } + + HashCollisionNode(final int hash, + final List>> collisionContent) { + this.hash = hash; + this.collisionContent = collisionContent; + } + + private static final RuntimeException UOE = new UnsupportedOperationException(); + + private static final Supplier UOE_NOT_YET_IMPLEMENTED_FACTORY = + () -> new UnsupportedOperationException("Not yet implemented @ HashCollisionNode."); + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + CompactSetMultimapNode getNode(int index) { + throw UOE; + } + + @Override + boolean hasPayload(EitherSingletonOrCollection.Type type) { + switch (type) { + case SINGLETON: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).findAny() + .isPresent(); + case COLLECTION: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).findAny() + .isPresent(); + } + throw new RuntimeException(); + } + + @Override + int payloadArity(EitherSingletonOrCollection.Type type) { + switch (type) { + case SINGLETON: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).count(); + case COLLECTION: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).count(); + } + throw new RuntimeException(); + } + + @Override + K getSingletonKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getKey(); + } + + @Override + V getSingletonValue(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getValue().stream().findAny().get(); + } + + @Override + K getCollectionKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getKey(); + } + + @Override + AbstractSetNode getCollectionValue(int index) { + io.usethesource.capsule.Set.Immutable result = collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getValue(); + + return setToNode(result); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return collisionContent.size() * 2; + } + + @Override + Object getSlot(int index) { + if (index % 2 == 0) { + return collisionContent.get(index / 2).getKey(); + } else { + return collisionContent.get(index / 2).getValue(); + } + } + + @Override + boolean containsKey(K key, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny() + .isPresent(); + } + + @Override + boolean containsTuple(K key, V val, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) + && entry.getValue().containsEquivalent(val, cmp.toComparator())) + .findAny().isPresent(); + } + + @Override + Optional> findByKey(K key, int keyHash, int shift, + EqualityComparator cmp) { + throw UOE_NOT_YET_IMPLEMENTED_FACTORY.get(); + } + + @Override + CompactSetMultimapNode inserted(AtomicReference mutator, K key, V val, + int keyHash, int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + if (values.containsEquivalent(val, cmp.toComparator())) { + // contains key and value + details.unchanged(); + return this; + + } else { + // contains key but not value + + Function>, Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = + values.__insertEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + // TODO does not check that remainder is unmodified + assert updatedCollisionContent.size() == collisionContent.size(); + assert updatedCollisionContent.contains(optionalTuple.get()) == false; + // assert updatedCollisionContent.contains(entryOf(key, values.__insertEquivalent(val, + // cmp.toComparator()))); + assert updatedCollisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) + && entry.getValue().containsEquivalent(val, cmp.toComparator())) + .findAny().isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder() + .add(entryOf(key, setOf(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + assert updatedCollisionContent.size() == collisionContent.size() + 1; + assert updatedCollisionContent.containsAll(collisionContent); + // assert updatedCollisionContent.contains(entryOf(key, setOf(val))); + assert updatedCollisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey()) + && Objects.equals(setOf(val), entry.getValue())).findAny().isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode updated(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key -> replace val anyways + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = values + .__insertEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + if (values.size() == 1) { + details.updated(values.stream().findAny().get()); // unbox singleton + } else { + details.updated(setToNode(values)); + } + + return new HashCollisionNode(hash, updatedCollisionContent); + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder() + .add(entryOf(key, setOf(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode removed(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + if (values.containsEquivalent(val, cmp.toComparator())) { + // contains key and value -> remove mapping + + final List>> updatedCollisionContent; + + if (values.size() == 1) { + updatedCollisionContent = collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry != optionalTuple.get()) + .collect(Collectors.toList()); + } else { + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = + values.__removeEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + } + + details.updated(val); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + details.unchanged(); + return this; + } + + @Override + State stateOfSingleton() { + return null; + } + } + + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueSingletonCursor; + protected int currentValueSingletonLength; + protected int currentValueCollectionCursor; + protected int currentValueCollectionLength; + protected AbstractSetMultimapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractSetMultimapNode[] nodes = new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapIterator(AbstractSetMultimapNode rootNode) { + int nodeArity = rootNode.nodeArity(); + if (nodeArity != 0) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = nodeArity; + } + + int emptyArity = rootNode.emptyArity(); + if (emptyArity + nodeArity < 32) { + currentValueNode = rootNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = rootNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = rootNode.payloadArity(COLLECTION); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractSetMultimapNode nextNode = + nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + int nodeArity = nextNode.nodeArity(); + if (nodeArity != 0) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nodeArity; + } + + // int emptyArity = nextNode.emptyArity(); + // if (emptyArity + nodeArity < 32) { + if (nextNode.hasPayload(SINGLETON) || nextNode.hasPayload(COLLECTION)) { + // if (payloadAritySingleton != 0 || payloadArityCollection != 0) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = nextNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = nextNode.payloadArity(Type.COLLECTION); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueSingletonCursor < currentValueSingletonLength + || currentValueCollectionCursor < currentValueCollectionLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetMultimapKeyIterator extends AbstractSetMultimapIterator + implements Iterator { + + SetMultimapKeyIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return currentValueNode.getSingletonKey(currentValueSingletonCursor++); + } else { + return currentValueNode.getCollectionKey(currentValueCollectionCursor++); + } + } + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIteratorLowLevel { + + private static final int MAX_DEPTH = 7; + + protected AbstractSetMultimapNode payloadNode; + protected long payloadOffset; + protected long payloadOutOfBounds; + + private int stackLevel = -1; + private final long[] stackOfOffsetsAndOutOfBounds = new long[MAX_DEPTH * 2]; + private final AbstractSetMultimapNode[] stackOfNodes = + new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapIteratorLowLevel(AbstractSetMultimapNode rootNode) { + // int nodeArity = rootNode.nodeArity(); + // int anyTupleArity = 32 - nodeArity - rootNode.emptyArity(); + + int[] arities = rootNode.arities(); + + int nodeArity = arities[PATTERN_NODE]; + int anyTupleArity = 32 - nodeArity - arities[PATTERN_EMPTY]; + + long offsetPayload = CompactSetMultimapNode.arrayBase; + long lengthPayload = anyTupleArity * 2 * addressSize; + + long offsetNodes = offsetPayload + lengthPayload; + long lengthNodes = nodeArity * addressSize; + + long offsetOutOfBounds = offsetNodes + lengthNodes; + + if (nodeArity != 0) { + stackLevel = 0; + + stackOfNodes[0] = rootNode; + stackOfOffsetsAndOutOfBounds[0] = offsetNodes; + stackOfOffsetsAndOutOfBounds[1] = offsetOutOfBounds; + } + + if (anyTupleArity != 0) { + payloadNode = rootNode; + payloadOffset = offsetPayload; + payloadOutOfBounds = offsetNodes; + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (stackLevel >= 0) { + final int currentCursorIndex = stackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final long nodeCursorAddress = stackOfOffsetsAndOutOfBounds[currentCursorIndex]; + final long nodeLengthAddress = stackOfOffsetsAndOutOfBounds[currentLengthIndex]; + + if (nodeCursorAddress < nodeLengthAddress) { + final AbstractSetMultimapNode nextNode = + getFromObjectRegionAndCast(stackOfNodes[stackLevel], nodeCursorAddress); + stackOfOffsetsAndOutOfBounds[currentCursorIndex] += addressSize; + + // int nodeArity = nextNode.nodeArity(); + // int anyTupleArity = 32 - nodeArity - nextNode.emptyArity(); + + int[] arities = nextNode.arities(); + + int nodeArity = arities[PATTERN_NODE]; + int anyTupleArity = 32 - nodeArity - arities[PATTERN_EMPTY]; + + long offsetPayload = CompactSetMultimapNode.arrayBase; + long lengthPayload = anyTupleArity * 2 * addressSize; + + long offsetNodes = offsetPayload + lengthPayload; + long lengthNodes = nodeArity * addressSize; + + long offsetOutOfBounds = offsetNodes + lengthNodes; + + if (nodeArity != 0) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++stackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + stackOfNodes[nextStackLevel] = nextNode; + stackOfOffsetsAndOutOfBounds[nextCursorIndex] = offsetNodes; + stackOfOffsetsAndOutOfBounds[nextLengthIndex] = offsetOutOfBounds; + } + + if (anyTupleArity != 0) { + /* + * found next node that contains values + */ + payloadNode = nextNode; + payloadOffset = offsetPayload; + payloadOutOfBounds = offsetNodes; + + return true; + } + } else { + stackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (payloadOffset < payloadOutOfBounds) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIteratorHistogram { + + private static final int MAX_DEPTH = 7; + + protected AbstractSetMultimapNode payloadNode; + protected int payloadCursorX; + protected int payloadCursorY; + protected long payloadOffset; + + protected int[] histogram; + protected int payloadRemaining; + + private int stackLevel = -1; + private final long[] stackOfOffsetsAndOutOfBounds = new long[MAX_DEPTH * 2]; + private final AbstractSetMultimapNode[] stackOfNodes = + new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapIteratorHistogram(AbstractSetMultimapNode rootNode) { + int[] arities = rootNode.arities(); + + int nodeArity = arities[PATTERN_NODE]; + int anyTupleArity = 32 - nodeArity - arities[PATTERN_EMPTY]; + + long offsetPayload = CompactSetMultimapNode.arrayBase; + long lengthPayload = anyTupleArity * 2 * addressSize; + + if (nodeArity != 0) { + stackLevel = 0; + + long offsetNodes = offsetPayload + lengthPayload; + long lengthNodes = nodeArity * addressSize; + + stackOfNodes[0] = rootNode; + stackOfOffsetsAndOutOfBounds[0] = offsetNodes; + stackOfOffsetsAndOutOfBounds[1] = offsetNodes + lengthNodes; + } + + if (anyTupleArity != 0) { + payloadRemaining = anyTupleArity; + + payloadNode = rootNode; + payloadCursorX = PATTERN_DATA_SINGLETON; + payloadCursorY = 0; + + payloadOffset = offsetPayload; + } + + histogram = arities; + } + + private boolean searchNextPayloadCategory() { + while (histogram[++payloadCursorX] == 0) { + ; + } + payloadCursorY = 0; + + return true; + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (stackLevel >= 0) { + final int currentCursorIndex = stackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final long nodeCursorAddress = stackOfOffsetsAndOutOfBounds[currentCursorIndex]; + final long nodeLengthAddress = stackOfOffsetsAndOutOfBounds[currentLengthIndex]; + + if (nodeCursorAddress < nodeLengthAddress) { + final AbstractSetMultimapNode nextNode = + getFromObjectRegionAndCast(stackOfNodes[stackLevel], nodeCursorAddress); + stackOfOffsetsAndOutOfBounds[currentCursorIndex] += addressSize; + + int[] arities = nextNode.arities(); + + int nodeArity = arities[PATTERN_NODE]; + int anyTupleArity = 32 - nodeArity - arities[PATTERN_EMPTY]; + + long offsetPayload = CompactSetMultimapNode.arrayBase; + long lengthPayload = anyTupleArity * 2 * addressSize; + + if (nodeArity != 0) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++stackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + long offsetNodes = offsetPayload + lengthPayload; + long lengthNodes = nodeArity * addressSize; + + stackOfNodes[nextStackLevel] = nextNode; + stackOfOffsetsAndOutOfBounds[nextCursorIndex] = offsetNodes; + stackOfOffsetsAndOutOfBounds[nextLengthIndex] = offsetNodes + lengthNodes; + } + + if (anyTupleArity != 0) { + /* + * found next node that contains values + */ + histogram = arities; + payloadRemaining = anyTupleArity; + + payloadNode = nextNode; + payloadCursorX = PATTERN_DATA_SINGLETON; + payloadCursorY = 0; + + payloadOffset = offsetPayload; + + return true; + } + } else { + stackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (payloadCursorY < histogram[payloadCursorX]) { + return true; + } else if (payloadRemaining != 0) { + return searchNextPayloadCategory(); + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetMultimapKeyIteratorHistogram + extends AbstractSetMultimapIteratorHistogram implements Iterator { + + SetMultimapKeyIteratorHistogram(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + switch (payloadCursorX) { + case PATTERN_DATA_SINGLETON: + case PATTERN_DATA_COLLECTION: + long nextOffset = payloadOffset; + + payloadCursorY += 1; + payloadRemaining -= 1; + payloadOffset = nextOffset + 2 * addressSize; + + return getFromObjectRegionAndCast(payloadNode, nextOffset); + default: + throw new IllegalStateException(); + } + } + } + + } + + protected static class SetMultimapKeyIteratorLowLevel + extends AbstractSetMultimapIteratorLowLevel implements Iterator { + + SetMultimapKeyIteratorLowLevel(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + long nextOffset = payloadOffset; + + K nextKey = getFromObjectRegionAndCast(payloadNode, nextOffset); + payloadOffset = nextOffset + 2 * addressSize; + + return nextKey; + } + } + + } + + protected static class SetMultimapNativeTupleIteratorLowLevel + extends AbstractSetMultimapIteratorLowLevel implements Iterator> { + + SetMultimapNativeTupleIteratorLowLevel(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + long nextOffset = payloadOffset; + + K nextKey = getFromObjectRegionAndCast(payloadNode, nextOffset); + nextOffset += addressSize; + Object nextVal = getFromObjectRegion(payloadNode, nextOffset); + nextOffset += addressSize; + + payloadOffset = nextOffset; + + return entryOf(nextKey, nextVal); + } + } + + } + + private static class FlatteningIterator implements Iterator> { + + final Iterator> entryIterator; + + K lastKey = null; + Iterator lastIterator = Collections.emptyIterator(); + + public FlatteningIterator(Iterator> entryIterator) { + this.entryIterator = entryIterator; + } + + @Override + public boolean hasNext() { + if (lastIterator.hasNext()) { + return true; + } else { + return entryIterator.hasNext(); + } + } + + @Override + public Entry next() { + assert hasNext(); + + if (lastIterator.hasNext()) { + return entryOf(lastKey, lastIterator.next()); + } else { + lastKey = null; + + Entry nextEntry = entryIterator.next(); + + Object singletonOrSet = nextEntry.getValue(); + + if (singletonOrSet instanceof AbstractSetNode) { + AbstractSetNode set = (AbstractSetNode) singletonOrSet; + + lastKey = nextEntry.getKey(); + lastIterator = set.iterator(); + + return entryOf(lastKey, lastIterator.next()); + } else { + return (Map.Entry) nextEntry; + } + } + } + + } + + protected static class SetMultimapValueIterator extends AbstractSetMultimapIterator + implements Iterator> { + + SetMultimapValueIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public AbstractSetNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return setNodeOf(currentValueNode.getSingletonValue(currentValueSingletonCursor++)); + } else { + return currentValueNode.getCollectionValue(currentValueCollectionCursor++); + } + } + } + + } + + protected static class SetMultimapNativeTupleIterator + extends AbstractSetMultimapIterator implements Iterator> { + + SetMultimapNativeTupleIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + final K currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + final Object currentValue = + currentValueNode.getSingletonValue(currentValueSingletonCursor); + currentValueSingletonCursor++; + + return AbstractSpecialisedImmutableMap.entryOf(currentKey, currentValue); + } else { + final K currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + final Object currentValue = + currentValueNode.getCollectionValue(currentValueCollectionCursor); + currentValueCollectionCursor++; + + return AbstractSpecialisedImmutableMap.entryOf(currentKey, currentValue); + } + } + } + + } + + protected static class SetMultimapTupleIterator extends AbstractSetMultimapIterator + implements Iterator { + + final BiFunction tupleOf; + + K currentKey = null; + V currentValue = null; + Iterator currentSetIterator = Collections.emptyIterator(); + + SetMultimapTupleIterator(AbstractSetMultimapNode rootNode, + final BiFunction tupleOf) { + super(rootNode); + this.tupleOf = tupleOf; + } + + @Override + public boolean hasNext() { + if (currentSetIterator.hasNext()) { + return true; + } else { + if (super.hasNext()) { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + currentSetIterator = Collections + .singleton(currentValueNode.getSingletonValue(currentValueSingletonCursor)) + .iterator(); + currentValueSingletonCursor++; + } else { + currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + currentSetIterator = + currentValueNode.getCollectionValue(currentValueCollectionCursor).iterator(); + currentValueCollectionCursor++; + } + + return true; + } else { + return false; + } + } + } + + @Override + public T next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + currentValue = currentSetIterator.next(); + return tupleOf.apply(currentKey, currentValue); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieSetMultimap_BleedingEdgeNodeIterator + implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieSetMultimap_BleedingEdgeNodeIterator(AbstractSetMultimapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractSetMultimapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieSetMultimap_BleedingEdge + implements SetMultimap.Transient { + + private final EqualityComparator cmp; + + final private AtomicReference mutator; + private AbstractSetMultimapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieSetMultimap_BleedingEdge( + TrieSetMultimap_HHAMT_Specialized_Interlinked trieSetMultimap_BleedingEdge) { + this.cmp = trieSetMultimap_BleedingEdge.cmp; + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieSetMultimap_BleedingEdge.rootNode; + this.hashCode = trieSetMultimap_BleedingEdge.hashCode; + this.cachedSize = trieSetMultimap_BleedingEdge.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.equals(iterator.next(), o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get().contains(val, val.hashCode(), 0); + } else { + return false; + } + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return setFromNode(result.get()); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public boolean __insert(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean union(final SetMultimap setMultimap) { + boolean modified = false; + + for (Map.Entry entry : setMultimap.entrySet()) { + modified |= this.__insert(entry.getKey(), entry.getValue()); + } + + return modified; + } + + @Override + public boolean __remove(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return false; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new TransientSetMultimapKeyIterator<>(this); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(AbstractSetNode::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + return new TransientSetMultimapTupleIterator<>(this, + AbstractSpecialisedImmutableMap::entryOf); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new TransientSetMultimapTupleIterator<>(this, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + public static class TransientSetMultimapKeyIterator extends SetMultimapKeyIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + K lastKey; + + public TransientSetMultimapKeyIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapValueIterator + extends SetMultimapValueIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapValueIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public AbstractSetNode next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapTupleIterator + extends SetMultimapTupleIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapTupleIterator( + final TransientTrieSetMultimap_BleedingEdge collection, + final BiFunction tupleOf) { + super(collection.rootNode, tupleOf); + this.collection = collection; + } + + @Override + public T next() { + return super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(currentKey, currentValue); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieSetMultimap_BleedingEdge.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieSetMultimap_BleedingEdge) { + TransientTrieSetMultimap_BleedingEdge that = + (TransientTrieSetMultimap_BleedingEdge) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + final AbstractSetNode valColl = (AbstractSetNode) entry.getValue(); + + if (!cmp.equals(result.get(), valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public SetMultimap.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieSetMultimap_HHAMT_Specialized_Interlinked(cmp, rootNode, hashCode, + cachedSize); + } + } + + private abstract static class DataLayoutHelper extends CompactSetMultimapNode { + + private static final long[] arrayOffsets = + arrayOffsets(DataLayoutHelper.class, new String[]{"slot0", "slot1"}); + + public final Object slot0 = null; + + public final Object slot1 = null; + + private DataLayoutHelper() { + super(null, 0L); + } + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.java new file mode 100644 index 0000000..8ad4fea --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/multimap/TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.java @@ -0,0 +1,4331 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.multimap; + +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Deque; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import io.usethesource.capsule.SetMultimap; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Path_Interlinked.SetMultimap0To0Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Path_Interlinked.SetMultimap0To1Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Path_Interlinked.SetMultimap0To2Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Path_Interlinked.SetMultimap0To4Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Path_Interlinked.SetMultimap1To0Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Path_Interlinked.SetMultimap1To2Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Path_Interlinked.SetMultimap2To0Node; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.EitherSingletonOrCollection.Type; +import io.usethesource.capsule.experimental.specialized.TrieSet_5Bits_Spec0To8; +import io.usethesource.capsule.experimental.specialized.TrieSet_5Bits_Spec0To8.AbstractSetNode; +import io.usethesource.capsule.experimental.specialized.TrieSet_5Bits_Spec0To8.SetResult; +import io.usethesource.capsule.util.EqualityComparator; +import io.usethesource.capsule.util.RangecopyUtils; +import io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap; + +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_DATA_COLLECTION; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_DATA_SINGLETON; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_EMPTY; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.PATTERN_NODE; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setBitPattern; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.setFromNode; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.specSetNodeOf; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.specSetOf; +import static io.usethesource.capsule.experimental.multimap.SetMultimapUtils.specSetToNode; +import static io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.EitherSingletonOrCollection.Type.COLLECTION; +import static io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.EitherSingletonOrCollection.Type.SINGLETON; +import static io.usethesource.capsule.util.BitmapUtils.filter; +import static io.usethesource.capsule.util.BitmapUtils.index; +import static io.usethesource.capsule.util.DataLayoutHelper.addressSize; +import static io.usethesource.capsule.util.DataLayoutHelper.arrayOffsets; +import static io.usethesource.capsule.util.DataLayoutHelper.fieldOffset; +import static io.usethesource.capsule.util.DataLayoutHelper.unsafe; +import static io.usethesource.capsule.util.RangecopyUtils._do_rangecompareObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.getFromObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.getFromObjectRegionAndCast; +import static io.usethesource.capsule.util.RangecopyUtils.rangecopyObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.setInObjectRegion; +import static io.usethesource.capsule.util.RangecopyUtils.setInObjectRegionVarArgs; +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +/** + * NOTE: only difference to {@link TrieSetMultimap_HHAMT_Specialized_Interlinked} is the use of + * {@link SetMultimapUtils#specSetNodeOf} instead of of {@link SetMultimapUtils#setNodeOf}. + * + * TODO: unify by injecting factory method. + */ +public class TrieSetMultimap_HHAMT_Specialized_Path_Interlinked + implements SetMultimap.Immutable { + + private final EqualityComparator cmp; + + protected static final CompactSetMultimapNode EMPTY_NODE = new SetMultimap0To0Node<>(null, 0L); + + private static final TrieSetMultimap_HHAMT_Specialized_Path_Interlinked EMPTY_SETMULTIMAP = + new TrieSetMultimap_HHAMT_Specialized_Path_Interlinked(EqualityComparator.EQUALS, EMPTY_NODE, + 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractSetMultimapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieSetMultimap_HHAMT_Specialized_Path_Interlinked(EqualityComparator cmp, + AbstractSetMultimapNode rootNode, int hashCode, int cachedSize) { + this.cmp = cmp; + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final SetMultimap.Immutable of() { + return TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.EMPTY_SETMULTIMAP; + } + + public static final SetMultimap.Immutable of(EqualityComparator cmp) { + // TODO: unify with `of()` + return new TrieSetMultimap_HHAMT_Specialized_Path_Interlinked(cmp, EMPTY_NODE, 0, 0); + } + + public static final SetMultimap.Immutable of(K key, V... values) { + SetMultimap.Immutable result = + TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.EMPTY_SETMULTIMAP; + + for (V value : values) { + result = result.__insert(key, value); + } + + return result; + } + + public static final SetMultimap.Transient transientOf() { + return TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.EMPTY_SETMULTIMAP.asTransient(); + } + + public static final SetMultimap.Transient transientOf(K key, V... values) { + final SetMultimap.Transient result = + TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.EMPTY_SETMULTIMAP.asTransient(); + + for (V value : values) { + result.__insert(key, value); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.equals(iterator.next(), o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + return rootNode.containsTuple(key, val, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return setFromNode(result.get()); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public SetMultimap.Immutable __put(K key, V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieSetMultimap_HHAMT_Specialized_Path_Interlinked(cmp, newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + final int valHashNew = val.hashCode(); + + return new TrieSetMultimap_HHAMT_Specialized_Path_Interlinked(cmp, newRootNode, + hashCode + ((keyHash ^ valHashNew)) - sumOfReplacedHashes, + cachedSize - details.getReplacedCollection().size() + 1); + } + } + + final int valHash = val.hashCode(); + return new TrieSetMultimap_HHAMT_Specialized_Path_Interlinked(cmp, newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable __insert(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + final int valHash = val.hashCode(); + return new TrieSetMultimap_HHAMT_Specialized_Path_Interlinked(cmp, newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable union( + final SetMultimap setMultimap) { + final SetMultimap.Transient tmpTransient = this.asTransient(); + tmpTransient.union(setMultimap); + return tmpTransient.freeze(); + } + + @Override + public SetMultimap.Immutable __remove(final K key, final V val) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap_HHAMT_Specialized_Path_Interlinked(cmp, newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + @Override + public SetMultimap.Immutable __remove(K key) { + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removedAll(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + + if (details.getType() == EitherSingletonOrCollection.Type.SINGLETON) { + final int valHash = details.getReplacedValue().hashCode(); + return new TrieSetMultimap_HHAMT_Specialized_Path_Interlinked(cmp, newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } else { + int sumOfReplacedHashes = 0; + + for (V replaceValue : details.getReplacedCollection()) { + sumOfReplacedHashes += (keyHash ^ replaceValue.hashCode()); + } + + return new TrieSetMultimap_HHAMT_Specialized_Path_Interlinked(cmp, newRootNode, + hashCode - sumOfReplacedHashes, cachedSize - details.getReplacedCollection().size()); + } + } + + return this; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new SetMultimapKeyIteratorLowLevel<>(rootNode); + // return new SetMultimapKeyIteratorHistogram<>(rootNode); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(AbstractSetNode::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + // return new SetMultimapTupleIterator<>(rootNode, AbstractSpecialisedImmutableMap::entryOf); + + return new FlatteningIterator<>(nativeEntryIterator()); + } + + @Override + public Iterator> nativeEntryIterator() { + // return new SetMultimapNativeTupleIterator<>(rootNode); + return new SetMultimapNativeTupleIteratorLowLevel<>(rootNode); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new SetMultimapTupleIterator<>(rootNode, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.this.keyIterator(); + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.this.valueIterator(); + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieSetMultimap_HHAMT_Specialized_Path_Interlinked) { + TrieSetMultimap_HHAMT_Specialized_Path_Interlinked that = + (TrieSetMultimap_HHAMT_Specialized_Path_Interlinked) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + final AbstractSetNode valColl = (AbstractSetNode) entry.getValue(); + + if (!cmp.equals(result.get(), valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public SetMultimap.Transient asTransient() { + return new TransientTrieSetMultimap_BleedingEdge(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractSetMultimapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieSetMultimap_BleedingEdgeNodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + // /* + // * For analysis purposes only. Payload X Node + // */ + // protected int[][] arityCombinationsHistogram() { + // final Iterator> it = nodeIterator(); + // final int[][] sumArityCombinations = new int[33][33]; + // + // while (it.hasNext()) { + // final AbstractSetMultimapNode node = it.next(); + // sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + // } + // + // return sumArityCombinations; + // } + // + // /* + // * For analysis purposes only. + // */ + // protected int[] arityHistogram() { + // final int[][] sumArityCombinations = arityCombinationsHistogram(); + // final int[] sumArity = new int[33]; + // + // final int maxArity = 32; // TODO: factor out constant + // + // for (int j = 0; j <= maxArity; j++) { + // for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + // sumArity[j + k] += sumArityCombinations[j][k]; + // } + // } + // + // return sumArity; + // } + // + // /* + // * For analysis purposes only. + // */ + // public void printStatistics() { + // final int[][] sumArityCombinations = arityCombinationsHistogram(); + // final int[] sumArity = arityHistogram(); + // final int sumNodes = getNodeCount(); + // + // final int[] cumsumArity = new int[33]; + // for (int cumsum = 0, i = 0; i < 33; i++) { + // cumsum += sumArity[i]; + // cumsumArity[i] = cumsum; + // } + // + // final float threshhold = 0.01f; // for printing results + // for (int i = 0; i < 33; i++) { + // float arityPercentage = (float) (sumArity[i]) / sumNodes; + // float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + // + // if (arityPercentage != 0 && arityPercentage >= threshhold) { + // // details per level + // StringBuilder bldr = new StringBuilder(); + // int max = i; + // for (int j = 0; j <= max; j++) { + // for (int k = max - j; k <= max - j; k++) { + // float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + // + // if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + // bldr.append(String.format("%d/%d: %s, ", j, k, + // new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + // } + // } + // } + // final String detailPercentages = bldr.toString(); + // + // // overview + // System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + // new DecimalFormat("0.00%").format(arityPercentage), + // new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + // } + // } + // } + + static abstract class EitherSingletonOrCollection { + + public enum Type { + SINGLETON, COLLECTION + } + + public static final EitherSingletonOrCollection of(T value) { + return new SomeSingleton<>(value); + } + + public static final EitherSingletonOrCollection of(AbstractSetNode value) { + return new SomeCollection<>(value); + } + + abstract boolean isType(Type type); + + abstract T getSingleton(); + + abstract AbstractSetNode getCollection(); + } + + static final class SomeSingleton extends EitherSingletonOrCollection { + + private final T value; + + private SomeSingleton(T value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.SINGLETON; + } + + @Override + T getSingleton() { + return value; + } + + @Override + AbstractSetNode getCollection() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.COLLECTION, Type.SINGLETON)); + } + } + + static final class SomeCollection extends EitherSingletonOrCollection { + + private final AbstractSetNode value; + + private SomeCollection(AbstractSetNode value) { + this.value = value; + } + + @Override + boolean isType(Type type) { + return type == Type.COLLECTION; + } + + @Override + T getSingleton() { + throw new UnsupportedOperationException(String + .format("Requested type %s but actually found %s.", Type.SINGLETON, Type.COLLECTION)); + } + + @Override + AbstractSetNode getCollection() { + return value; + } + } + + static final class SetMultimapResult { + + private V replacedValue; + private AbstractSetNode replacedValueCollection; + private EitherSingletonOrCollection.Type replacedType; + + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(V replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + this.replacedType = SINGLETON; + } + + public void updated(AbstractSetNode replacedValueCollection) { + this.replacedValueCollection = replacedValueCollection; + this.isModified = true; + this.isReplaced = true; + this.replacedType = COLLECTION; + } + + // update: neither element, nor element count changed + public static SetMultimapResult unchanged() { + return new SetMultimapResult<>(); + } + + private SetMultimapResult() { + } + + public boolean isModified() { + return isModified; + } + + public EitherSingletonOrCollection.Type getType() { + return replacedType; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public V getReplacedValue() { + assert getType() == SINGLETON; + return replacedValue; + } + + public AbstractSetNode getReplacedCollection() { + assert getType() == COLLECTION; + return replacedValueCollection; + } + } + + protected static interface INode { + + } + + protected static abstract class AbstractSetMultimapNode implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract boolean containsTuple(final K key, final V val, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract Optional> findByKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp); + + abstract CompactSetMultimapNode inserted(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode updated(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode removed(final AtomicReference mutator, + final K key, final V val, final int keyHash, final int shift, + final SetMultimapResult details, EqualityComparator cmp); + + abstract CompactSetMultimapNode removedAll(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractSetMultimapNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractSetMultimapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractSetMultimapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract int emptyArity(); + + // @Deprecated // split data / coll arity + abstract boolean hasPayload(); + + // + // @Deprecated // split data / coll arity + abstract int payloadArity(); + + abstract boolean hasPayload(EitherSingletonOrCollection.Type type); + + // abstract int payloadArity(); + + abstract int payloadArity(EitherSingletonOrCollection.Type type); + + abstract K getSingletonKey(final int index); + + abstract V getSingletonValue(final int index); + + abstract K getCollectionKey(final int index); + + abstract AbstractSetNode getCollectionValue(final int index); + + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + abstract int arity(); + + abstract int[] arities(); + + int size() { + final Iterator it = new SetMultimapKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactSetMultimapNode + extends AbstractSetMultimapNode { + + private long bitmap; + + private int cachedSlotArity; + private int cachedNodeArity; + private int cachedEmptyArity; + + @Deprecated + final void initializeLazyFields() { + // NOTE: temporariliy used to test caching of attributes; will be removed soon again + + // cachedSlotArity = (int) staticSlotArity(); + // cachedNodeArity = (int) Long.bitCount(filter(bitmap, PATTERN_NODE)); + // cachedEmptyArity = (int) Long.bitCount(filter(bitmap, PATTERN_EMPTY)); + } + + CompactSetMultimapNode(final AtomicReference mutator, final long bitmap) { + this.bitmap = bitmap; + initializeLazyFields(); + } + + // TODO: removed `final` due to HashCollisionNode + long bitmap() { + return bitmap; + } + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + static final int doubledMask(int keyHash, int shift) { + final int mask = mask(keyHash, shift); + return mask << 1; + } + + static final long doubledBitpos(final int doubledMask) { + return 1L << doubledMask; + } + + static final int pattern(long bitmap, int doubledMask) { + return (int) ((bitmap >>> doubledMask) & 0b11); + } + + static final long initializeArrayBase() { + try { + // assuems that both are of type Object and next to each other in memory + return DataLayoutHelper.arrayOffsets[0]; + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + static final long arrayBase = initializeArrayBase(); + + // static final Class[][] initializeSpecializationsByContentAndNodes() { + // Class[][] next = new Class[33][65]; + // + // try { + // for (int m = 0; m <= 32; m++) { + // for (int n = 0; n <= 64; n++) { + // int mNext = m; + // int nNext = n; + // + // // TODO: last expression is not properly generated yet and maybe incorrect + // if (mNext < 0 || mNext > 32 || nNext < 0 || nNext > 64 + // || Math.ceil(nNext / 2.0) + mNext > 32) { + // next[m][n] = null; + // } else { + // next[m][n] = Class.forName(String.format( + // "io.usethesource.capsule.TrieSetMultimap_HHAMT_Specializations_Interlinked$SetMultimap%dTo%dNode", + // mNext, nNext)); + // } + // } + // } + // } catch (ClassNotFoundException e) { + // throw new RuntimeException(e); + // } + // + // return next; + // } + // + // static final Class[][] specializationsByContentAndNodes = + // initializeSpecializationsByContentAndNodes(); + + static final Class[] initializeSpecializationsByContentAndNodes() { + Class[] next = new Class[33 * 65]; + + try { + for (int m = 0; m <= 32; m++) { + for (int n = 0; n <= 64; n++) { + int mNext = m; + int nNext = n; + + // TODO: last expression is not properly generated yet and maybe incorrect + if (mNext < 0 || mNext > 32 || nNext < 0 || nNext > 64 + || Math.ceil(nNext / 2.0) + mNext > 32) { + next[65 * m + n] = null; + } else { + next[65 * m + n] = Class.forName(String.format( + "io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specializations_Path_Interlinked$SetMultimap%dTo%dNode", + mNext, nNext)); + } + } + } + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } + + return next; + } + + static final Class[] specializationsByContentAndNodes = + initializeSpecializationsByContentAndNodes(); + + static final T allocateHeapRegion(final Class[] lookupTable, final int dim1, + final int dim2) { + final Class clazz = lookupTable[65 * dim1 + dim2]; + return RangecopyUtils.allocateHeapRegion(clazz); + } + + // static final byte[] initializeMetadataByContentAndNodes() { + // byte[] next = new byte[33 * 65 * 4]; + // + // try { + // for (int m = 0; m <= 32; m++) { + // for (int n = 0; n <= 64; n++) { + // int mNext = m; + // int nNext = n; + // + // // TODO: last expression is not properly generated yet and maybe incorrect + // if (mNext < 0 || mNext > 32 || nNext < 0 || nNext > 64 + // || Math.ceil(nNext / 2.0) + mNext > 32) { + //// int section = (65 * m + n) * 4; + //// next[65 * m + n] = 0; + // } else { + // Class clazz = Class.forName(String.format( + // "io.usethesource.capsule.TrieSetMultimap_HHAMT_Specializations_Interlinked$SetMultimap%dTo%dNode", + // mNext, nNext)); + // + // int section = (65 * m + n) * 4; + // next[section + 0] = (byte) unsafe.getLong(clazz, globalRareBaseOffset); + // next[section + 1] = (byte) unsafe.getInt(clazz, globalPayloadArityOffset); + // next[section + 2] = (byte) unsafe.getInt(clazz, globalUntypedSlotArityOffset); + // next[section + 3] = (byte) unsafe.getInt(clazz, globalSlotArityOffset); + // + // if (next[section + 0] < 0) + // System.out.println(next[section + 0]); + // } + // } + // } + // } catch (ClassNotFoundException e) { + // throw new RuntimeException(e); + // } + // + // return next; + // } + // + // static final byte[] metadataByContentAndNodes = + // initializeMetadataByContentAndNodes(); + + static long globalRawMap1Offset = fieldOffset(SetMultimap0To2Node.class, "rawMap1"); + + static long globalRawMap2Offset = fieldOffset(SetMultimap0To2Node.class, "rawMap2"); + + static long globalArrayOffsetsOffset = fieldOffset(SetMultimap0To2Node.class, "arrayOffsets"); + + static long globalNodeArityOffset = fieldOffset(SetMultimap0To2Node.class, "nodeArity"); + + static long globalPayloadArityOffset = fieldOffset(SetMultimap0To2Node.class, "payloadArity"); + + static long globalSlotArityOffset = fieldOffset(SetMultimap0To2Node.class, "slotArity"); + + static long globalUntypedSlotArityOffset = + fieldOffset(SetMultimap0To2Node.class, "untypedSlotArity"); + + static long globalRareBaseOffset = fieldOffset(SetMultimap0To2Node.class, "rareBase"); + + static long globalArrayOffsetLastOffset = + fieldOffset(SetMultimap0To2Node.class, "arrayOffsetLast"); + + static long globalNodeBaseOffset = fieldOffset(SetMultimap0To2Node.class, "nodeBase"); + + private final long staticRareBase() { + return unsafe.getLong(this.getClass(), globalRareBaseOffset); + } + + private final int staticSlotArity() { + return unsafe.getInt(this.getClass(), globalSlotArityOffset); + } + + private final int staticUntypedSlotArity() { + return unsafe.getInt(this.getClass(), globalUntypedSlotArityOffset); + } + + private final int staticPayloadArity() { + return unsafe.getInt(this.getClass(), globalPayloadArityOffset); + } + + // @Deprecated + // abstract int dataMap(); + // + // @Deprecated + // abstract int collMap(); + // + // @Deprecated + // abstract int nodeMap(); + + // TODO: use final modifer when decoupling collision node from compact node + @Override + boolean hasPayload() { + return payloadArity() != 0; + } + + // TODO: use final modifer when decoupling collision node from compact node + @Override + int payloadArity() { + return 32 - nodeArity() - emptyArity(); + } + + // TODO: use final modifer when decoupling collision node from compact node + @Override + boolean hasPayload(EitherSingletonOrCollection.Type type) { + return payloadArity(type) != 0; + } + + // TODO: use final modifer when decoupling collision node from compact node + @Override + int payloadArity(EitherSingletonOrCollection.Type type) { + if (type == Type.SINGLETON) { + return arity(bitmap(), PATTERN_DATA_SINGLETON); + } else { + return arity(bitmap(), PATTERN_DATA_COLLECTION); + } + } + + // TODO: use final modifer when decoupling collision node from compact node + @Override + K getSingletonKey(final int index) { + return (K) getFromObjectRegion(this, arrayBase, TUPLE_LENGTH * index); + } + + // TODO: use final modifer when decoupling collision node from compact node + @Override + V getSingletonValue(final int index) { + return (V) getFromObjectRegion(this, arrayBase, TUPLE_LENGTH * index + 1); + } + + // TODO: use final modifer when decoupling collision node from compact node + @Override + K getCollectionKey(final int index) { + return (K) getFromObjectRegion(this, staticRareBase(), TUPLE_LENGTH * index); + } + + // TODO: use final modifer when decoupling collision node from compact node + @Override + AbstractSetNode getCollectionValue(final int index) { + return (AbstractSetNode) getFromObjectRegion(this, staticRareBase(), + TUPLE_LENGTH * index + 1); + } + + // TODO: use final modifer when decoupling collision node from compact node + @Override + boolean hasSlots() { + return slotArity() != 0; + } + + // TODO: use final modifer when decoupling collision node from compact node + @Override + int slotArity() { + return staticSlotArity(); + + // return cachedSlotArity; + } + + // TODO: use final modifer when decoupling collision node from compact node + @Override + Object getSlot(final int index) { + return getFromObjectRegion(this, arrayBase, index); + } + + // TODO: use final modifer when decoupling collision node from compact node + @Override + int emptyArity() { + return Long.bitCount(filter(bitmap, PATTERN_EMPTY)); + // return arity(bitmap, PATTERN_EMPTY); + + // return cachedEmptyArity; + } + + @Deprecated + @Override + int arity() { + // TODO: replace with 32 - arity(emptyMap) + // return arity(bitmap(), PATTERN_DATA_SINGLETON) + arity(bitmap(), PATTERN_DATA_COLLECTION) + + // arity(bitmap(), PATTERN_NODE); + + int[] arities = arities(bitmap()); + return Arrays.stream(arities).skip(1).sum(); + } + + static final int arity(long bitmap, int pattern) { + // if (bitmap == 0) { + // if (pattern == PATTERN_EMPTY) { + // return 32; + // } else { + // return 0; + // } + // } else { + // return Long.bitCount(filter(bitmap, pattern)); + // } + + long filteredBitmap = filter(bitmap, pattern); + + // if (filteredBitmap == 0) { + // if (pattern == PATTERN_EMPTY) { + // return 32; + // } else { + // return 0; + // } + // } + + return Long.bitCount(filteredBitmap); + } + + @Override + public int[] arities() { + return arities(bitmap); + } + + static final int[] arities(final long bitmap) { + int[] arities = new int[4]; + + arities[0] = Long.bitCount(filter(bitmap, PATTERN_EMPTY)); + arities[1] = Long.bitCount(filter(bitmap, PATTERN_DATA_SINGLETON)); + arities[2] = Long.bitCount(filter(bitmap, PATTERN_DATA_COLLECTION)); + arities[3] = Long.bitCount(filter(bitmap, PATTERN_NODE)); + + return arities; + } + + static final int[] aritiesSingleLoopOverLong(final long bitmap) { + int[] arities = new int[4]; + + long shiftedBitmap = bitmap; + for (int i = 0; i < 32; i++) { + arities[(int) shiftedBitmap & 0b11]++; + shiftedBitmap = shiftedBitmap >>> 2; + } + + return arities; + } + + static final int[] aritiesDoubleLoopOverInt(final long bitmap) { + int[] arities = new int[4]; + + int segment0 = (int) (bitmap >>> 32); + int segment1 = (int) (bitmap); + + for (int i = 0; i < 16; i++) { + arities[segment0 & 0b11]++; + segment0 = segment0 >>> 2; + } + + for (int i = 0; i < 16; i++) { + arities[segment1 & 0b11]++; + segment1 = segment1 >>> 2; + } + + return arities; + } + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + byte sizePredicate() { + final long bitmap = this.bitmap(); + + int nodeArity = arity(bitmap, PATTERN_NODE); + int emptyArity = arity(bitmap, PATTERN_EMPTY); + + if (nodeArity > 0) { + return SIZE_MORE_THAN_ONE; + } else { + switch (emptyArity) { + case 32: + return SIZE_EMPTY; + case 31: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } + } + + @Override + boolean hasNodes() { + return nodeArity() != 0; + } + + // TODO: use final modifer when decoupling collision node from compact node + @Override + int nodeArity() { + return Long.bitCount(filter(bitmap, PATTERN_NODE)); + // return arity(bitmap, PATTERN_NODE); + + // return cachedNodeArity; + } + + // TODO: use final modifer when decoupling collision node from compact node + @Override + CompactSetMultimapNode getNode(final int index) { + final int pIndex = slotArity() - 1 - index; + + return (CompactSetMultimapNode) getSlot(pIndex); + + // final long rareBase = staticRareBase(); + // + // final int untypedSlotArity = staticUntypedSlotArity(); + // final int pIndex = untypedSlotArity - 1 - index; + // + // return (CompactSetMultimapNode) getFromObjectRegion(this, rareBase, pIndex); + } + + void assertNodeInvariant() { + // return true; + // boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + // boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + // boolean inv3 = + // (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + // boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + // + // boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + // && ((this.payloadArity() + this.nodeArity()) == this.arity()); + // + // return inv1 && inv2 && inv3 && inv4 && inv5; + + // if (DEBUG) { + int[] arities = arities(bitmap); + + assert (TUPLE_LENGTH * arities[PATTERN_DATA_SINGLETON] + + TUPLE_LENGTH * arities[PATTERN_DATA_COLLECTION] + arities[PATTERN_NODE] == slotArity()); + + for (int i = 0; i < arities[PATTERN_DATA_SINGLETON]; i++) { + int offset = i * TUPLE_LENGTH; + + assert ((getSlot(offset + 0) instanceof AbstractSetNode) == false); + assert ((getSlot(offset + 1) instanceof AbstractSetNode) == false); + + assert ((getSlot(offset + 0) instanceof CompactSetMultimapNode) == false); + assert ((getSlot(offset + 1) instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arities[PATTERN_DATA_COLLECTION]; i++) { + int offset = (i + arities[PATTERN_DATA_SINGLETON]) * TUPLE_LENGTH; + + assert ((getSlot(offset + 0) instanceof AbstractSetNode) == false); + assert ((getSlot(offset + 1) instanceof AbstractSetNode) == true); + + assert ((getSlot(offset + 0) instanceof CompactSetMultimapNode) == false); + assert ((getSlot(offset + 1) instanceof CompactSetMultimapNode) == false); + } + + for (int i = 0; i < arities[PATTERN_NODE]; i++) { + int offset = + (arities[PATTERN_DATA_SINGLETON] + arities[PATTERN_DATA_COLLECTION]) * TUPLE_LENGTH; + + assert ((getSlot(offset + i) instanceof AbstractSetNode) == false); + + assert ((getSlot(offset + i) instanceof CompactSetMultimapNode) == true); + } + } + // } + + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + final long updatedBitmap) { + final Class srcClass = this.getClass(); + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = RangecopyUtils.allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.bitmap = updatedBitmap; + + rangecopyObjectRegion(src, dst, arrayBase, staticSlotArity()); + + // dst.assertNodeInvariant(); + // dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndSetSingletonValue(final AtomicReference mutator, + final long doubledBitpos, final V val) { + final int index = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = RangecopyUtils.allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.bitmap = bitmap; + + final int slotArity = staticSlotArity(); + int pIndex = TUPLE_LENGTH * index + 1; + + rangecopyObjectRegion(src, arrayBase, dst, arrayBase, slotArity); + setInObjectRegion(dst, arrayBase, pIndex, val); + + // dst.assertNodeInvariant(); + // dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndSetCollectionValue(final AtomicReference mutator, + final long doubledBitpos, final AbstractSetNode valColl) { + final int index = collIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = RangecopyUtils.allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.bitmap = bitmap; + + final int slotArity = staticSlotArity(); + int pIndex = TUPLE_LENGTH * index + 1; + + rangecopyObjectRegion(src, arrayBase, dst, arrayBase, slotArity); + setInObjectRegion(dst, staticRareBase(), pIndex, valColl); + + // dst.assertNodeInvariant(); + // dst.initializeLazyFields(); + return dst; + } + + static final CompactSetMultimapNode allocateHeapRegionAndSetBitmap( + final Class clazz, final long bitmap) { + try { + final CompactSetMultimapNode newInstance = + (CompactSetMultimapNode) unsafe.allocateInstance(clazz); + newInstance.bitmap = bitmap; + return newInstance; + } catch (ClassCastException | InstantiationException e) { + throw new RuntimeException(e); + } + } + + CompactSetMultimapNode copyAndSetNode(final AtomicReference mutator, + final int index, final CompactSetMultimapNode node) { + final Class srcClass = this.getClass(); + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = RangecopyUtils.allocateHeapRegion(srcClass); + + // copy and update bitmaps + dst.bitmap = bitmap; + + final int slotArity = staticSlotArity(); + final int pIndex = slotArity - 1 - index; + + // single copy spanning over all references + rangecopyObjectRegion(src, dst, arrayBase, slotArity); + setInObjectRegion(dst, arrayBase, pIndex, node); + + // dst.assertNodeInvariant(); + // dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndInsertSingleton(final AtomicReference mutator, + final long doubledBitpos, final K key, final V val) { + final int index = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = + allocateHeapRegion(specializationsByContentAndNodes, payloadArity + 1, untypedSlotArity); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_SINGLETON); + + final int pIndex = TUPLE_LENGTH * index; + + long offset = arrayBase; + long delta = 0; + + offset += rangecopyObjectRegion(src, dst, offset, pIndex); + delta += setInObjectRegionVarArgs(dst, offset, key, val); + offset += rangecopyObjectRegion(src, offset, dst, offset + delta, slotArity - pIndex); + + // dst.assertNodeInvariant(); + // dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + final AtomicReference mutator, final long doubledBitpos, final int indexOld, + final K key, final AbstractSetNode valColl) { + // final int indexOld = dataIndex(doubledBitpos); + final int indexNew = collIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity - 1, untypedSlotArity + 2); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_COLLECTION); + + final int pIndexOld = TUPLE_LENGTH * indexOld; + final int pIndexNew = TUPLE_LENGTH * (payloadArity - 1 + indexNew); + + /* TODO: test code below; not sure that length arguments are correct */ + + long offset = arrayBase; + long delta2 = addressSize * 2; + + offset += rangecopyObjectRegion(src, dst, offset, pIndexOld); + offset += rangecopyObjectRegion(src, offset + delta2, dst, offset, pIndexNew - pIndexOld); + setInObjectRegionVarArgs(dst, offset, key, valColl); + offset += rangecopyObjectRegion(src, dst, offset + delta2, slotArity - pIndexNew - 2); + + // dst.assertNodeInvariant(); + // dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndRemoveSingleton(final AtomicReference mutator, + final long doubledBitpos) { + final int indexOld = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + if (payloadArity == 1 && untypedSlotArity == 0) { + // TODO: check if this optimization can be performed in caller + return EMPTY_NODE; + } else { + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity - 1, untypedSlotArity); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_EMPTY); + + final int pIndexOld = TUPLE_LENGTH * indexOld; + + long offset = arrayBase; + offset += rangecopyObjectRegion(src, dst, offset, pIndexOld); + long delta = 2 * addressSize /* sizeOfInt() */; + offset += rangecopyObjectRegion(src, offset + delta, dst, offset, + (TUPLE_LENGTH * (payloadArity - 1) - pIndexOld + untypedSlotArity)); + + // dst.assertNodeInvariant(); + // dst.initializeLazyFields(); + return dst; + } + } + + /* + * Batch updated, necessary for removedAll. + */ + CompactSetMultimapNode copyAndRemoveCollection(final AtomicReference mutator, + final long doubledBitpos) { + final int indexOld = collIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + if (payloadArity == 0 && untypedSlotArity == TUPLE_LENGTH) { + // TODO: check if this optimization can be performed in caller + return EMPTY_NODE; + } else { + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity, untypedSlotArity - TUPLE_LENGTH); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_EMPTY); + + final int pIndexOld = TUPLE_LENGTH * (payloadArity + indexOld); + + long offset = arrayBase; + offset += rangecopyObjectRegion(src, dst, offset, pIndexOld); + long delta = 2 * addressSize /* sizeOfInt() */; + offset += rangecopyObjectRegion(src, offset + delta, dst, offset, + (TUPLE_LENGTH * (payloadArity - 1) - pIndexOld + untypedSlotArity)); + + // dst.assertNodeInvariant(); + // dst.initializeLazyFields(); + return dst; + } + } + + CompactSetMultimapNode copyAndMigrateFromSingletonToNode( + final AtomicReference mutator, final long doubledBitpos, final int indexOld, + final CompactSetMultimapNode node) { + // final int indexOld = dataIndex(doubledBitpos); + final int indexNew = nodeIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity - 1, untypedSlotArity + 1); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_NODE); + + final int pIndexOld = TUPLE_LENGTH * indexOld; + final int pIndexNew = (slotArity - 1) - 1 - indexNew; + + copyAndMigrateFromXxxToNode(src, dst, slotArity, pIndexOld, pIndexNew, node); + + // dst.assertNodeInvariant(); + // dst.initializeLazyFields(); + return dst; + } + + private void copyAndMigrateFromXxxToNode(final CompactSetMultimapNode src, + final CompactSetMultimapNode dst, final int slotArity, final int pIndexOld, + final int pIndexNew, final CompactSetMultimapNode node) { + long offset = arrayBase; + long delta1 = addressSize; + long delta2 = 2 * addressSize; + + offset += rangecopyObjectRegion(src, dst, offset, pIndexOld); + offset += rangecopyObjectRegion(src, offset + delta2, dst, offset, pIndexNew - pIndexOld); + + setInObjectRegionVarArgs(dst, offset, node); + + offset += rangecopyObjectRegion(src, offset + delta2, dst, offset + delta1, + slotArity - pIndexNew - 2); + } + + CompactSetMultimapNode copyAndMigrateFromCollectionToNode( + final AtomicReference mutator, final long doubledBitpos, final int indexOld, + final CompactSetMultimapNode node) { + // final int indexOld = collIndex(doubledBitpos); + final int indexNew = nodeIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity, untypedSlotArity - TUPLE_LENGTH + 1); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_NODE); + + final int pIndexOld = TUPLE_LENGTH * (payloadArity + indexOld); + final int pIndexNew = (slotArity - 1) - 1 - indexNew; + + copyAndMigrateFromXxxToNode(src, dst, slotArity, pIndexOld, pIndexNew, node); + + // dst.assertNodeInvariant(); + // dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node) { // node get's unwrapped inside method + + final int indexOld = nodeIndex(doubledBitpos); + final int indexNew = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity + 1, untypedSlotArity - 1); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_SINGLETON); + + final int pIndexOld = slotArity - 1 - indexOld; + final int pIndexNew = TUPLE_LENGTH * indexNew; + + Object keyToInline = node.getSingletonKey(0); + Object valToInline = node.getSingletonValue(0); + + copyAndMigrateFromNodeToXxx(src, dst, slotArity, pIndexOld, pIndexNew, keyToInline, + valToInline); + + // dst.assertNodeInvariant(); + // dst.initializeLazyFields(); + return dst; + } + + CompactSetMultimapNode copyAndMigrateFromNodeToCollection( + final AtomicReference mutator, final long doubledBitpos, + final CompactSetMultimapNode node) { // node get's unwrapped inside method + + final int indexOld = nodeIndex(doubledBitpos); + final int indexNew = collIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity, untypedSlotArity - 1 + TUPLE_LENGTH); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_COLLECTION); + + final int pIndexOld = slotArity - 1 - indexOld; + final int pIndexNew = TUPLE_LENGTH * indexNew; + + Object keyToInline = node.getCollectionKey(0); + Object valToInline = node.getCollectionValue(0); + + copyAndMigrateFromNodeToXxx(src, dst, slotArity, pIndexOld, pIndexNew, keyToInline, + valToInline); + + // dst.assertNodeInvariant(); + // dst.initializeLazyFields(); + return dst; + } + + private void copyAndMigrateFromNodeToXxx(final CompactSetMultimapNode src, + final CompactSetMultimapNode dst, final int slotArity, final int pIndexOld, + final int pIndexNew, Object keyToInline, Object valToInline) { + long offset = arrayBase; + long delta1 = addressSize; + long delta2 = delta1 * 2; + + offset += rangecopyObjectRegion(src, dst, offset, pIndexNew); + setInObjectRegionVarArgs(dst, offset, keyToInline, valToInline); + offset += rangecopyObjectRegion(src, offset, dst, offset + delta2, pIndexOld - pIndexNew); + offset += rangecopyObjectRegion(src, offset + delta1, dst, offset + delta2, + slotArity - pIndexOld - 1); + } + + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + final AtomicReference mutator, final long doubledBitpos, final K key, final V val) { + + // TODO: does not support src == dst yet for shifting + + final int indexOld = collIndex(doubledBitpos); + final int indexNew = dataIndex(doubledBitpos); + + final Class srcClass = this.getClass(); + + // TODO: introduce slotArity constant in specializations + // final int slotArity = unsafe.getInt(srcClass, globalSlotArityOffset); + final int payloadArity = staticPayloadArity(); + final int untypedSlotArity = staticUntypedSlotArity(); + + final int slotArity = TUPLE_LENGTH * payloadArity + untypedSlotArity; + + final CompactSetMultimapNode src = this; + final CompactSetMultimapNode dst = allocateHeapRegion(specializationsByContentAndNodes, + payloadArity + 1, untypedSlotArity - 2); + + dst.bitmap = setBitPattern(bitmap, doubledBitpos, PATTERN_DATA_SINGLETON); + + final int pIndexOld = TUPLE_LENGTH * (payloadArity + indexOld); + final int pIndexNew = TUPLE_LENGTH * indexNew; + + long offset = arrayBase; + long delta2 = addressSize * 2; + + offset += rangecopyObjectRegion(src, dst, offset, pIndexNew); + setInObjectRegionVarArgs(dst, offset, key, val); + offset += rangecopyObjectRegion(src, offset, dst, offset + delta2, pIndexOld - pIndexNew); + offset += rangecopyObjectRegion(src, dst, offset + delta2, slotArity - pIndexOld - 2); + + // dst.assertNodeInvariant(); + // dst.initializeLazyFields(); + return dst; + } + + // TODO: fix hash collision support + static final CompactSetMultimapNode mergeTwoSingletonPairs(final K key0, + final V val0, final int keyHash0, final K key1, final V val1, final int keyHash1, + final int shift, EqualityComparator cmp) { + assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode.of(keyHash0, key0, specSetOf(val0), key1, specSetOf(val1)); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_SINGLETON); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_SINGLETON); + + if (mask0 < mask1) { + return nodeOf0x2(null, bitmap, key0, val0, key1, val1); + } else { + return nodeOf0x2(null, bitmap, key1, val1, key0, val0); + } + } else { + final CompactSetMultimapNode node = mergeTwoSingletonPairs(key0, val0, keyHash0, key1, + val1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf1x0(null, bitmap, node); + } + } + + // TODO: fix hash collision support + static final CompactSetMultimapNode mergeCollectionAndSingletonPairs(final K key0, + final AbstractSetNode valColl0, final int keyHash0, final K key1, final V val1, + final int keyHash1, final int shift, EqualityComparator cmp) { + assert !(cmp.equals(key0, key1)); + + if (shift >= HASH_CODE_LENGTH) { + return AbstractHashCollisionNode.of(keyHash0, key0, setFromNode(valColl0), key1, + specSetOf(val1)); + } + + final int mask0 = doubledMask(keyHash0, shift); + final int mask1 = doubledMask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + long bitmap = 0L; + bitmap = setBitPattern(bitmap, doubledBitpos(mask0), PATTERN_DATA_COLLECTION); + bitmap = setBitPattern(bitmap, doubledBitpos(mask1), PATTERN_DATA_SINGLETON); + + // singleton before collection + return nodeOf2x1(null, bitmap, key1, val1, key0, valColl0); + } else { + final CompactSetMultimapNode node = mergeCollectionAndSingletonPairs(key0, valColl0, + keyHash0, key1, val1, keyHash1, shift + BIT_PARTITION_SIZE, cmp); + // values fit on next level + final long bitmap = setBitPattern(0L, doubledBitpos(mask0), PATTERN_NODE); + + return nodeOf1x0(null, bitmap, node); + } + } + + // static final int index(final int bitmap, final int bitpos) { + // return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + // } + // + // static final int index(final int bitmap, final int mask, final int bitpos) { + // return (bitmap == -1) ? mask : index(bitmap, bitpos); + // } + + @Deprecated + int dataIndex(final long doubledBitpos) { + return index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + } + + @Deprecated + int collIndex(final long doubledBitpos) { + return index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + } + + @Deprecated + int nodeIndex(final long doubledBitpos) { + return index(bitmap, PATTERN_NODE, doubledBitpos); + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + return cmp.equals(getSingletonKey(index), key); + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + return cmp.equals(getCollectionKey(index), key); + } + default: + return false; + } + } + + @Override + boolean containsTuple(final K key, final V val, final int keyHash, final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + + final AbstractSetMultimapNode subNode = getNode(index); + return subNode.containsTuple(key, val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(index); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(index); + return cmp.equals(currentVal, val); + } + + return false; + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(index); + if (cmp.equals(currentKey, key)) { + + final AbstractSetNode currentValColl = getCollectionValue(index); + return currentValColl.contains(val, val.hashCode(), 0); + } + + return false; + } + default: + return false; + } + } + + @Override + Optional> findByKey(final K key, final int keyHash, final int shift, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int index = index(bitmap, PATTERN_NODE, doubledBitpos); + + final AbstractSetMultimapNode subNode = getNode(index); + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + case PATTERN_DATA_SINGLETON: { + int index = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(index); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(index); + return Optional.of(specSetNodeOf(currentVal)); + } + + return Optional.empty(); + } + case PATTERN_DATA_COLLECTION: { + int index = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(index); + if (cmp.equals(currentKey, key)) { + + final AbstractSetNode currentValColl = getCollectionValue(index); + return Optional.of(currentValColl); + } + + return Optional.empty(); + } + default: + return Optional.empty(); + } + } + + @Override + CompactSetMultimapNode inserted(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = subNode.inserted(mutator, key, val, + keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + if (cmp.equals(currentVal, val)) { + return this; + } else { + // migrate from singleton to collection + final AbstractSetNode valColl = specSetNodeOf(currentVal, val); + + details.modified(); + return copyAndMigrateFromSingletonToCollection(mutator, doubledBitpos, dataIndex, + currentKey, valColl); + } + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, dataIndex, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final AbstractSetNode currentCollVal = getCollectionValue(collIndex); + + if (currentCollVal.contains(val, val.hashCode(), 0)) { + return this; + } else { + // add new mapping + final AbstractSetNode newCollVal = + currentCollVal.updated(mutator, val, val.hashCode(), 0, SetResult.unchanged()); + + details.modified(); + return copyAndSetCollectionValue(mutator, doubledBitpos, newCollVal); + } + } else { + // prefix-collision (case: collection x singleton) + final AbstractSetNode currentValNode = getCollectionValue(collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, collIndex, + subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertSingleton(mutator, doubledBitpos, key, val); + } + } + } + + @Override + CompactSetMultimapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } else { + return this; + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + final K currentKey = getSingletonKey(dataIndex); + + if (cmp.equals(currentKey, key)) { + final V currentVal = getSingletonValue(dataIndex); + + // update singleton value + details.updated(currentVal); + return copyAndSetSingletonValue(mutator, doubledBitpos, val); + } else { + // prefix-collision (case: singleton x singleton) + final V currentVal = getSingletonValue(dataIndex); + + final CompactSetMultimapNode subNodeNew = mergeTwoSingletonPairs(currentKey, + currentVal, transformHashCode(currentKey.hashCode()), key, val, keyHash, + shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromSingletonToNode(mutator, doubledBitpos, dataIndex, subNodeNew); + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + final K currentCollKey = getCollectionKey(collIndex); + + if (cmp.equals(currentCollKey, key)) { + final AbstractSetNode currentCollVal = getCollectionValue(collIndex); + + // migrate from collection to singleton + details.updated(currentCollVal); + return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, currentCollKey, + val); + } else { + // prefix-collision (case: collection x singleton) + final AbstractSetNode currentValNode = getCollectionValue(collIndex); + final CompactSetMultimapNode subNodeNew = mergeCollectionAndSingletonPairs( + currentCollKey, currentValNode, transformHashCode(currentCollKey.hashCode()), key, + val, keyHash, shift + BIT_PARTITION_SIZE, cmp); + + details.modified(); + return copyAndMigrateFromCollectionToNode(mutator, doubledBitpos, collIndex, + subNodeNew); + } + } + default: { + details.modified(); + return copyAndInsertSingleton(mutator, doubledBitpos, key, val); + } + } + } + + @Override + CompactSetMultimapNode removed(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.removed(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (slotArity() == 0) { + if (shift == 0) { + // singleton remaining + final long doubledBitposAtShift0 = doubledBitpos(bitpos(doubledMask(keyHash, 0))); + + final long updatedBitmapAtShift0 = + setBitPattern(doubledBitposAtShift0, subNodeNew.patternOfSingleton()); + + return subNodeNew.copyAndUpdateBitmaps(mutator, updatedBitmapAtShift0); + } else { + // escalate (singleton or empty) result + return subNodeNew; + } + } else { + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + } + + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(dataIndex); + if (cmp.equals(currentVal, val)) { + + // remove mapping + details.updated(val); + return copyAndRemoveSingleton(mutator, doubledBitpos); + } else { + return this; + } + } else { + return this; + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(collIndex); + if (cmp.equals(currentKey, key)) { + + final AbstractSetNode currentValColl = getCollectionValue(collIndex); + if (currentValColl.contains(val, val.hashCode(), 0)) { + + // remove mapping + details.updated(val); + + final AbstractSetNode newValColl = + currentValColl.removed(mutator, val, val.hashCode(), 0, SetResult.unchanged()); + + if (newValColl.size() == 1) { + // TODO: investigate options for unboxing singleton collections + V remainingVal = newValColl.iterator().next(); + return copyAndMigrateFromCollectionToSingleton(mutator, doubledBitpos, key, + remainingVal); + } else { + return copyAndSetCollectionValue(mutator, doubledBitpos, newValColl); + } + } else { + return this; + } + } else { + return this; + } + } + default: + return this; + } + } + + final static boolean hasSingleNode(int[] arities) { + return arities[PATTERN_EMPTY] == 31 && arities[PATTERN_NODE] == 1; + } + + final static boolean hasTwoPayloads(int[] arities) { + return arities[PATTERN_EMPTY] == 30 && arities[PATTERN_NODE] == 0; + } + + enum State { + EMPTY, NODE, PAYLOAD, PAYLOAD_RARE + } + + static final State toState(final int pattern) { + // final State[] states = {State.EMPTY, State.NODE, State.PAYLOAD, State.PAYLOAD_RARE}; + // return states[pattern]; + + switch (pattern) { + case PATTERN_EMPTY: + return State.EMPTY; + case PATTERN_NODE: + return State.NODE; + case PATTERN_DATA_SINGLETON: + return State.PAYLOAD; + default: + return State.PAYLOAD_RARE; + } + } + + @Override + CompactSetMultimapNode removedAll(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetMultimapResult details, + EqualityComparator cmp) { + long bitmap = this.bitmap(); + + final int doubledMask = doubledMask(keyHash, shift); + final int pattern = pattern(bitmap, doubledMask); + + final long doubledBitpos = doubledBitpos(doubledMask); + + switch (pattern) { + case PATTERN_NODE: { + int nodeIndex = index(bitmap, PATTERN_NODE, doubledBitpos); + + final CompactSetMultimapNode subNode = getNode(nodeIndex); + final CompactSetMultimapNode subNodeNew = + subNode.removedAll(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + if (slotArity() == 1) { + if (shift == 0) { + // singleton remaining + final long doubledBitposAtShift0 = doubledBitpos(bitpos(doubledMask(keyHash, 0))); + + final long updatedBitmapAtShift0 = + setBitPattern(doubledBitposAtShift0, subNodeNew.patternOfSingleton()); + + return subNodeNew.copyAndUpdateBitmaps(mutator, updatedBitmapAtShift0); + } else { + // escalate (singleton or empty) result + return subNodeNew; + } + } else { + // // inline value (move to front) + // final State subNodeState = subNodeNew.stateOfSingleton(); + // + //// switch (subNodeState) { + //// case EMPTY: + //// case NODE: + //// case PAYLOAD: + //// return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + //// case PAYLOAD_RARE: + //// return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + //// } + // + // if (subNodeState == State.PAYLOAD) { + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // } else { + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // } + + // inline value (move to front) + EitherSingletonOrCollection.Type type = subNodeNew.typeOfSingleton(); + + if (type == EitherSingletonOrCollection.Type.SINGLETON) { + return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + } else { + return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + } + + // // inline value (move to front) + // final int subNodePattern = subNodeNew.patternOfSingleton(); + // + // if (subNodePattern == PATTERN_DATA_SINGLETON) { + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // } else { + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // } + + // switch (subNodePattern) { + // case PATTERN_DATA_SINGLETON: + // return copyAndMigrateFromNodeToSingleton(mutator, doubledBitpos, subNodeNew); + // case PATTERN_DATA_COLLECTION: + // return copyAndMigrateFromNodeToCollection(mutator, doubledBitpos, subNodeNew); + // default: + // return null; + // } + } + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, nodeIndex, subNodeNew); + } + } + } + case PATTERN_DATA_SINGLETON: { + int dataIndex = index(bitmap, PATTERN_DATA_SINGLETON, doubledBitpos); + + final K currentKey = getSingletonKey(dataIndex); + if (cmp.equals(currentKey, key)) { + + final V currentVal = getSingletonValue(dataIndex); + + details.updated(currentVal); + return copyAndRemoveSingleton(mutator, doubledBitpos); + } else { + return this; + } + } + case PATTERN_DATA_COLLECTION: { + int collIndex = index(bitmap, PATTERN_DATA_COLLECTION, doubledBitpos); + + final K currentKey = getCollectionKey(collIndex); + if (cmp.equals(currentKey, key)) { + + final AbstractSetNode currentValColl = getCollectionValue(collIndex); + + details.updated(currentValColl); + return copyAndRemoveCollection(mutator, doubledBitpos); + } else { + return this; + } + } + default: + return this; + } + } + + int patternOfSingleton() { + assert this.sizePredicate() == SIZE_ONE; + + long bitmap = this.bitmap(); + + final int doubledMask = Long.numberOfTrailingZeros(bitmap) / 2 * 2; + final int pattern = pattern(bitmap, doubledMask); + + return pattern; + } + + @Deprecated + State stateOfSingleton() { + assert this.sizePredicate() == SIZE_ONE; + + long bitmap = this.bitmap(); + + final int doubledMask = Long.numberOfTrailingZeros(bitmap) / 2 * 2; + final int pattern = pattern(bitmap, doubledMask); + + return toState(pattern); + } + + @Deprecated + EitherSingletonOrCollection.Type typeOfSingleton() { + final int pattern = patternOfSingleton(); + + if (pattern == PATTERN_DATA_SINGLETON) { + return EitherSingletonOrCollection.Type.SINGLETON; + } else { + return EitherSingletonOrCollection.Type.COLLECTION; + } + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + long bitmap = this.bitmap(); + + int[] arities = arities(bitmap); + + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < arities[PATTERN_DATA_SINGLETON]; i++) { + final byte pos = -1; // TODO: recoverMask(dataMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getSingletonKey(i)), + Objects.hashCode(getSingletonValue(i)))); + + if (!((i + 1) == arities[PATTERN_DATA_SINGLETON])) { + bldr.append(", "); + } + } + + if (arities[PATTERN_DATA_SINGLETON] > 0 && arities[PATTERN_DATA_COLLECTION] > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arities[PATTERN_DATA_COLLECTION]; i++) { + final byte pos = -1; // TODO: recoverMask(collMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getCollectionKey(i)), + Objects.hashCode(getCollectionValue(i)))); + + if (!((i + 1) == arities[PATTERN_DATA_COLLECTION])) { + bldr.append(", "); + } + } + + if (arities[PATTERN_DATA_COLLECTION] > 0 && arities[PATTERN_NODE] > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < arities[PATTERN_NODE]; i++) { + final byte pos = -1; // TODO: recoverMask(nodeMap, (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == arities[PATTERN_NODE])) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + CompactSetMultimapNode that = (CompactSetMultimapNode) other; + if (bitmap() != that.bitmap()) { + return false; + } + + return _do_rangecompareObjectRegion(this, that, arrayBase, slotArity()); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf1x0(final AtomicReference mutator, + final long bitmap, final Object slot0) { + return new SetMultimap0To1Node<>(mutator, bitmap, slot0); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf0x1(final AtomicReference mutator, + final long bitmap, final K key1, final V val1) { + return new SetMultimap1To0Node<>(mutator, bitmap, key1, val1); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf0x2(final AtomicReference mutator, + final long bitmap, final K key1, final V val1, final K key2, final V val2) { + return new SetMultimap2To0Node<>(mutator, bitmap, key1, val1, key2, val2); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf4x0(final AtomicReference mutator, + final long bitmap, final Object slot0, final Object slot1, final Object slot2, + final Object slot3) { + return new SetMultimap0To4Node<>(mutator, bitmap, slot0, slot1, slot2, slot3); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf2x0(final AtomicReference mutator, + final long bitmap, final Object slot0, final Object slot1) { + return new SetMultimap0To2Node<>(mutator, bitmap, slot0, slot1); + } + + // TODO: return abstract instead of compact node + static final CompactSetMultimapNode nodeOf2x1(final AtomicReference mutator, + final long bitmap, final K key1, final V val1, final Object slot0, final Object slot1) { + return new SetMultimap1To2Node<>(mutator, bitmap, key1, val1, slot0, slot1); + } + + } + + private static abstract class AbstractHashCollisionNode + extends CompactSetMultimapNode { + + // TODO: remove constructor and stored properties within CompactSetMultimapNode + AbstractHashCollisionNode() { + super(null, 0L); + } + + static final > AbstractHashCollisionNode of( + final int hash, final K key0, final VS valColl0, final K key1, final VS valColl1) { + return new HashCollisionNode<>(hash, key0, valColl0, key1, valColl1); + } + + private static final RuntimeException UOE_BOILERPLATE = new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + private static final Supplier UOE_FACTORY = + () -> new UnsupportedOperationException( + "TODO: CompactSetMultimapNode -> AbstractSetMultimapNode"); + + @Override + CompactSetMultimapNode copyAndSetSingletonValue(AtomicReference mutator, + long doubledBitpos, V val) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndSetCollectionValue(AtomicReference mutator, + long doubledBitpos, AbstractSetNode valColl) { + throw UOE_FACTORY.get(); + } + + // @Override + // CompactSetMultimapNode copyAndSetNode(AtomicReference mutator, long + // doubledBitpos, + // CompactSetMultimapNode node) { + // throw UOE_FACTORY.get(); + // } + + @Override + CompactSetMultimapNode copyAndInsertSingleton(AtomicReference mutator, + long doubledBitpos, K key, V val) { + throw UOE_FACTORY.get(); + } + + // @Override + // CompactSetMultimapNode copyAndMigrateFromSingletonToCollection( + // AtomicReference mutator, long doubledBitpos, K key, AbstractSetNode valColl) { + // throw UOE_FACTORY.get(); + // } + + @Override + CompactSetMultimapNode copyAndRemoveSingleton(AtomicReference mutator, + long doubledBitpos) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndRemoveCollection(AtomicReference mutator, + long doubledBitpos) { + throw UOE_FACTORY.get(); + } + + // @Override + // CompactSetMultimapNode copyAndMigrateFromSingletonToNode(AtomicReference + // mutator, + // long doubledBitpos, CompactSetMultimapNode node) { + // throw UOE_FACTORY.get(); + // } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToSingleton(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + // @Override + // CompactSetMultimapNode copyAndMigrateFromCollectionToNode(AtomicReference + // mutator, + // long doubledBitpos, CompactSetMultimapNode node) { + // throw UOE_FACTORY.get(); + // } + + @Override + CompactSetMultimapNode copyAndMigrateFromNodeToCollection(AtomicReference mutator, + long doubledBitpos, CompactSetMultimapNode node) { + throw UOE_FACTORY.get(); + } + + @Override + CompactSetMultimapNode copyAndUpdateBitmaps(AtomicReference mutator, + long bitmap) { + throw UOE_FACTORY.get(); + } + + // @Override + // CompactSetMultimapNode copyAndInsertCollection(AtomicReference mutator, + // long doubledBitpos, K key, AbstractSetNode valColl) { + // throw UOE_FACTORY.get(); + // } + + // @Override + // CompactSetMultimapNode copyAndRemoveSingleton(AtomicReference mutator, + // long doubledBitpos, long updatedBitmap) { + // throw UOE_FACTORY.get(); + // } + + @Override + CompactSetMultimapNode copyAndMigrateFromCollectionToSingleton( + AtomicReference mutator, long doubledBitpos, K key, V val) { + throw UOE_FACTORY.get(); + } + + // @Override + // long bitmap() { + // throw UOE_FACTORY.get(); + // } + // + // @Override + // int emptyArity() { + // throw UOE_FACTORY.get(); + // } + + @Override + Type typeOfSingleton() { + throw UOE_FACTORY.get(); + } + + @Override + int patternOfSingleton() { + throw UOE_FACTORY.get(); + } + + @Override + long bitmap() { + throw UOE_FACTORY.get(); + } + } + + private static final class HashCollisionNode extends AbstractHashCollisionNode { + + private final int hash; + private final List>> collisionContent; + + HashCollisionNode(final int hash, final K key0, + final io.usethesource.capsule.Set.Immutable valColl0, final K key1, + final io.usethesource.capsule.Set.Immutable valColl1) { + this(hash, Arrays.asList(entryOf(key0, valColl0), entryOf(key1, valColl1))); + } + + HashCollisionNode(final int hash, + final List>> collisionContent) { + this.hash = hash; + this.collisionContent = collisionContent; + + // NOTE: sorting ensures that SINGLETONs occur before COLLECTIONs + collisionContent.sort((o1, o2) -> o1.getValue().size() - o2.getValue().size()); + } + + private static final RuntimeException UOE = new UnsupportedOperationException(); + + private static final Supplier UOE_NOT_YET_IMPLEMENTED_FACTORY = + () -> new UnsupportedOperationException("Not yet implemented @ HashCollisionNode."); + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + CompactSetMultimapNode getNode(int index) { + throw UOE; + } + + @Override + boolean hasPayload(EitherSingletonOrCollection.Type type) { + switch (type) { + case SINGLETON: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).findAny() + .isPresent(); + case COLLECTION: + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).findAny() + .isPresent(); + } + throw new RuntimeException(); + } + + @Override + int payloadArity(EitherSingletonOrCollection.Type type) { + switch (type) { + case SINGLETON: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).count(); + case COLLECTION: + return (int) collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).count(); + } + throw new RuntimeException(); + } + + @Override + K getSingletonKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getKey(); + } + + @Override + V getSingletonValue(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() == 1).skip(index) + .findAny().get().getValue().stream().findAny().get(); + } + + @Override + K getCollectionKey(int index) { + return collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getKey(); + } + + @Override + AbstractSetNode getCollectionValue(int index) { + io.usethesource.capsule.Set.Immutable result = collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry.getValue().size() >= 2).skip(index) + .findAny().get().getValue(); + + return specSetToNode(result); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return collisionContent.size() * 2; + } + + @Override + Object getSlot(int index) { + if (index % 2 == 0) { + return collisionContent.get(index / 2).getKey(); + } else { + Object nextVal = collisionContent.get(index / 2).getValue(); + + if (nextVal instanceof TrieSet_5Bits_Spec0To8) { + return specSetToNode((TrieSet_5Bits_Spec0To8) nextVal); + } else { + return nextVal; + } + } + } + + @Override + public final int[] arities() { + int[] arities = new int[4]; + + arities[0] = 32 - payloadArity(SINGLETON) - payloadArity(COLLECTION); + arities[1] = payloadArity(SINGLETON); + arities[2] = payloadArity(COLLECTION); + arities[3] = 0; // PATTERN_NODE + + return arities; + } + + @Override + boolean containsKey(K key, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny() + .isPresent(); + } + + @Override + boolean containsTuple(K key, V val, int keyHash, int shift, EqualityComparator cmp) { + return collisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) + && entry.getValue().containsEquivalent(val, cmp.toComparator())) + .findAny().isPresent(); + } + + @Override + Optional> findByKey(K key, int keyHash, int shift, + EqualityComparator cmp) { + throw UOE_NOT_YET_IMPLEMENTED_FACTORY.get(); + } + + @Override + CompactSetMultimapNode inserted(AtomicReference mutator, K key, V val, + int keyHash, int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + if (values.containsEquivalent(val, cmp.toComparator())) { + // contains key and value + details.unchanged(); + return this; + + } else { + // contains key but not value + + Function>, Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = + values.__insertEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + // TODO does not check that remainder is unmodified + assert updatedCollisionContent.size() == collisionContent.size(); + assert updatedCollisionContent.contains(optionalTuple.get()) == false; + // assert updatedCollisionContent.contains(entryOf(key, values.__insertEquivalent(val, + // cmp.toComparator()))); + assert updatedCollisionContent.stream() + .filter(entry -> cmp.equals(key, entry.getKey()) + && entry.getValue().containsEquivalent(val, cmp.toComparator())) + .findAny().isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder() + .add(entryOf(key, specSetOf(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + // TODO not all API uses EqualityComparator + assert updatedCollisionContent.size() == collisionContent.size() + 1; + assert updatedCollisionContent.containsAll(collisionContent); + // assert updatedCollisionContent.contains(entryOf(key, specSetOf(val))); + assert updatedCollisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey()) + && Objects.equals(specSetOf(val), entry.getValue())).findAny().isPresent(); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode updated(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key -> replace val anyways + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = values + .__insertEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + List>> updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + + if (values.size() == 1) { + details.updated(values.stream().findAny().get()); // unbox singleton + } else { + details.updated(specSetToNode(values)); + } + + return new HashCollisionNode(hash, updatedCollisionContent); + } else { + // does not contain key + + Stream.Builder>> builder = + Stream.>>builder() + .add(entryOf(key, specSetOf(val))); + + collisionContent.forEach(builder::accept); + + List>> updatedCollisionContent = + builder.build().collect(Collectors.toList()); + + details.modified(); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + @Override + CompactSetMultimapNode removed(AtomicReference mutator, K key, V val, int keyHash, + int shift, SetMultimapResult details, EqualityComparator cmp) { + Optional>> optionalTuple = + collisionContent.stream().filter(entry -> cmp.equals(key, entry.getKey())).findAny(); + + if (optionalTuple.isPresent()) { + // contains key + + io.usethesource.capsule.Set.Immutable values = optionalTuple.get().getValue(); + + if (values.containsEquivalent(val, cmp.toComparator())) { + // contains key and value -> remove mapping + + final List>> updatedCollisionContent; + + if (values.size() == 1) { + updatedCollisionContent = collisionContent.stream() + .filter(kImmutableSetEntry -> kImmutableSetEntry != optionalTuple.get()) + .collect(Collectors.toList()); + } else { + Function>, Map.Entry>> substitutionMapper = + (kImmutableSetEntry) -> { + if (kImmutableSetEntry == optionalTuple.get()) { + io.usethesource.capsule.Set.Immutable updatedValues = + values.__removeEquivalent(val, cmp.toComparator()); + return entryOf(key, updatedValues); + } else { + return kImmutableSetEntry; + } + }; + + updatedCollisionContent = + collisionContent.stream().map(substitutionMapper).collect(Collectors.toList()); + } + + details.updated(val); + return new HashCollisionNode(hash, updatedCollisionContent); + } + } + + details.unchanged(); + return this; + } + + @Override + State stateOfSingleton() { + throw UOE_NOT_YET_IMPLEMENTED_FACTORY.get(); + } + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueSingletonCursor; + protected int currentValueSingletonLength; + protected int currentValueCollectionCursor; + protected int currentValueCollectionLength; + protected AbstractSetMultimapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractSetMultimapNode[] nodes = new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapIterator(AbstractSetMultimapNode rootNode) { + int nodeArity = rootNode.nodeArity(); + if (nodeArity != 0) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = nodeArity; + } + + int emptyArity = rootNode.emptyArity(); + if (emptyArity + nodeArity < 32) { + currentValueNode = rootNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = rootNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = rootNode.payloadArity(COLLECTION); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractSetMultimapNode nextNode = + nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + int nodeArity = nextNode.nodeArity(); + if (nodeArity != 0) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nodeArity; + } + + // int emptyArity = nextNode.emptyArity(); + // if (emptyArity + nodeArity < 32) { + if (nextNode.hasPayload(SINGLETON) || nextNode.hasPayload(COLLECTION)) { + // if (payloadAritySingleton != 0 || payloadArityCollection != 0) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueSingletonCursor = 0; + currentValueSingletonLength = nextNode.payloadArity(SINGLETON); + currentValueCollectionCursor = 0; + currentValueCollectionLength = nextNode.payloadArity(Type.COLLECTION); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueSingletonCursor < currentValueSingletonLength + || currentValueCollectionCursor < currentValueCollectionLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetMultimapKeyIterator extends AbstractSetMultimapIterator + implements Iterator { + + SetMultimapKeyIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return currentValueNode.getSingletonKey(currentValueSingletonCursor++); + } else { + return currentValueNode.getCollectionKey(currentValueCollectionCursor++); + } + } + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIteratorLowLevel { + + private static final int MAX_DEPTH = 7; + + protected AbstractSetMultimapNode payloadNode; + protected long payloadOffset; + protected long payloadOutOfBounds; + + private int stackLevel = -1; + private final long[] stackOfOffsetsAndOutOfBounds = new long[MAX_DEPTH * 2]; + private final AbstractSetMultimapNode[] stackOfNodes = + new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapIteratorLowLevel(AbstractSetMultimapNode rootNode) { + // int nodeArity = rootNode.nodeArity(); + // int anyTupleArity = 32 - nodeArity - rootNode.emptyArity(); + + int[] arities = rootNode.arities(); + + int nodeArity = arities[PATTERN_NODE]; + int anyTupleArity = 32 - nodeArity - arities[PATTERN_EMPTY]; + + long offsetPayload = CompactSetMultimapNode.arrayBase; + long lengthPayload = anyTupleArity * 2 * addressSize; + + long offsetNodes = offsetPayload + lengthPayload; + long lengthNodes = nodeArity * addressSize; + + long offsetOutOfBounds = offsetNodes + lengthNodes; + + if (nodeArity != 0) { + stackLevel = 0; + + stackOfNodes[0] = rootNode; + stackOfOffsetsAndOutOfBounds[0] = offsetNodes; + stackOfOffsetsAndOutOfBounds[1] = offsetOutOfBounds; + } + + if (anyTupleArity != 0) { + payloadNode = rootNode; + payloadOffset = offsetPayload; + payloadOutOfBounds = offsetNodes; + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (stackLevel >= 0) { + final int currentCursorIndex = stackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final long nodeCursorAddress = stackOfOffsetsAndOutOfBounds[currentCursorIndex]; + final long nodeLengthAddress = stackOfOffsetsAndOutOfBounds[currentLengthIndex]; + + if (nodeCursorAddress < nodeLengthAddress) { + final AbstractSetMultimapNode nextNode = + getFromObjectRegionAndCast(stackOfNodes[stackLevel], nodeCursorAddress); + stackOfOffsetsAndOutOfBounds[currentCursorIndex] += addressSize; + + // int nodeArity = nextNode.nodeArity(); + // int anyTupleArity = 32 - nodeArity - nextNode.emptyArity(); + + int[] arities = nextNode.arities(); + + int nodeArity = arities[PATTERN_NODE]; + int anyTupleArity = 32 - nodeArity - arities[PATTERN_EMPTY]; + + long offsetPayload = CompactSetMultimapNode.arrayBase; + long lengthPayload = anyTupleArity * 2 * addressSize; + + long offsetNodes = offsetPayload + lengthPayload; + long lengthNodes = nodeArity * addressSize; + + long offsetOutOfBounds = offsetNodes + lengthNodes; + + if (nodeArity != 0) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++stackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + stackOfNodes[nextStackLevel] = nextNode; + stackOfOffsetsAndOutOfBounds[nextCursorIndex] = offsetNodes; + stackOfOffsetsAndOutOfBounds[nextLengthIndex] = offsetOutOfBounds; + } + + if (anyTupleArity != 0) { + /* + * found next node that contains values + */ + payloadNode = nextNode; + payloadOffset = offsetPayload; + payloadOutOfBounds = offsetNodes; + + return true; + } + } else { + stackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (payloadOffset < payloadOutOfBounds) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetMultimapIteratorHistogram { + + private static final int MAX_DEPTH = 7; + + protected AbstractSetMultimapNode payloadNode; + protected int payloadCursorX; + protected int payloadCursorY; + protected long payloadOffset; + + protected int[] histogram; + protected int payloadRemaining; + + private int stackLevel = -1; + private final long[] stackOfOffsetsAndOutOfBounds = new long[MAX_DEPTH * 2]; + private final AbstractSetMultimapNode[] stackOfNodes = + new AbstractSetMultimapNode[MAX_DEPTH]; + + AbstractSetMultimapIteratorHistogram(AbstractSetMultimapNode rootNode) { + int[] arities = rootNode.arities(); + + int nodeArity = arities[PATTERN_NODE]; + int anyTupleArity = 32 - nodeArity - arities[PATTERN_EMPTY]; + + long offsetPayload = CompactSetMultimapNode.arrayBase; + long lengthPayload = anyTupleArity * 2 * addressSize; + + if (nodeArity != 0) { + stackLevel = 0; + + long offsetNodes = offsetPayload + lengthPayload; + long lengthNodes = nodeArity * addressSize; + + stackOfNodes[0] = rootNode; + stackOfOffsetsAndOutOfBounds[0] = offsetNodes; + stackOfOffsetsAndOutOfBounds[1] = offsetNodes + lengthNodes; + } + + if (anyTupleArity != 0) { + payloadRemaining = anyTupleArity; + + payloadNode = rootNode; + payloadCursorX = PATTERN_DATA_SINGLETON; + payloadCursorY = 0; + + payloadOffset = offsetPayload; + } + + histogram = arities; + } + + private boolean searchNextPayloadCategory() { + while (histogram[++payloadCursorX] == 0) { + ; + } + payloadCursorY = 0; + + return true; + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (stackLevel >= 0) { + final int currentCursorIndex = stackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final long nodeCursorAddress = stackOfOffsetsAndOutOfBounds[currentCursorIndex]; + final long nodeLengthAddress = stackOfOffsetsAndOutOfBounds[currentLengthIndex]; + + if (nodeCursorAddress < nodeLengthAddress) { + final AbstractSetMultimapNode nextNode = + getFromObjectRegionAndCast(stackOfNodes[stackLevel], nodeCursorAddress); + stackOfOffsetsAndOutOfBounds[currentCursorIndex] += addressSize; + + int[] arities = nextNode.arities(); + + int nodeArity = arities[PATTERN_NODE]; + int anyTupleArity = 32 - nodeArity - arities[PATTERN_EMPTY]; + + long offsetPayload = CompactSetMultimapNode.arrayBase; + long lengthPayload = anyTupleArity * 2 * addressSize; + + if (nodeArity != 0) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++stackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + long offsetNodes = offsetPayload + lengthPayload; + long lengthNodes = nodeArity * addressSize; + + stackOfNodes[nextStackLevel] = nextNode; + stackOfOffsetsAndOutOfBounds[nextCursorIndex] = offsetNodes; + stackOfOffsetsAndOutOfBounds[nextLengthIndex] = offsetNodes + lengthNodes; + } + + if (anyTupleArity != 0) { + /* + * found next node that contains values + */ + histogram = arities; + payloadRemaining = anyTupleArity; + + payloadNode = nextNode; + payloadCursorX = PATTERN_DATA_SINGLETON; + payloadCursorY = 0; + + payloadOffset = offsetPayload; + + return true; + } + } else { + stackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (payloadCursorY < histogram[payloadCursorX]) { + return true; + } else if (payloadRemaining != 0) { + return searchNextPayloadCategory(); + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetMultimapKeyIteratorHistogram + extends AbstractSetMultimapIteratorHistogram implements Iterator { + + SetMultimapKeyIteratorHistogram(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + switch (payloadCursorX) { + case PATTERN_DATA_SINGLETON: + case PATTERN_DATA_COLLECTION: + long nextOffset = payloadOffset; + + payloadCursorY += 1; + payloadRemaining -= 1; + payloadOffset = nextOffset + 2 * addressSize; + + return getFromObjectRegionAndCast(payloadNode, nextOffset); + default: + throw new IllegalStateException(); + } + } + } + + } + + protected static class SetMultimapKeyIteratorLowLevel + extends AbstractSetMultimapIteratorLowLevel implements Iterator { + + SetMultimapKeyIteratorLowLevel(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + long nextOffset = payloadOffset; + + K nextKey = getFromObjectRegionAndCast(payloadNode, nextOffset); + payloadOffset = nextOffset + 2 * addressSize; + + return nextKey; + } + } + + } + + protected static class SetMultimapNativeTupleIteratorLowLevel + extends AbstractSetMultimapIteratorLowLevel implements Iterator> { + + SetMultimapNativeTupleIteratorLowLevel(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + if (payloadNode instanceof HashCollisionNode) { + int slotIndex = (int) ((payloadOffset - CompactSetMultimapNode.arrayBase) / addressSize); + + K nextKey = (K) payloadNode.getSlot(slotIndex); + Object nextVal = payloadNode.getSlot(slotIndex + 1); + + payloadOffset = payloadOffset + 2 * addressSize; + + return entryOf(nextKey, nextVal); + } else { + long nextOffset = payloadOffset; + + K nextKey = getFromObjectRegionAndCast(payloadNode, nextOffset); + nextOffset += addressSize; + Object nextVal = getFromObjectRegion(payloadNode, nextOffset); + nextOffset += addressSize; + + payloadOffset = nextOffset; + + return entryOf(nextKey, nextVal); + } + } + } + + } + + private static class FlatteningIterator implements Iterator> { + + final Iterator> entryIterator; + + K lastKey = null; + Iterator lastIterator = Collections.emptyIterator(); + + public FlatteningIterator(Iterator> entryIterator) { + this.entryIterator = entryIterator; + } + + @Override + public boolean hasNext() { + if (lastIterator.hasNext()) { + return true; + } else { + return entryIterator.hasNext(); + } + } + + @Override + public Entry next() { + assert hasNext(); + + if (lastIterator.hasNext()) { + return entryOf(lastKey, lastIterator.next()); + } else { + lastKey = null; + + Entry nextEntry = entryIterator.next(); + + Object singletonOrSet = nextEntry.getValue(); + assert !(singletonOrSet instanceof io.usethesource.capsule.Set.Immutable); + + if (singletonOrSet instanceof AbstractSetNode) { + AbstractSetNode set = (AbstractSetNode) singletonOrSet; + + lastKey = nextEntry.getKey(); + lastIterator = set.iterator(); + + return entryOf(lastKey, lastIterator.next()); + } else { + return (Map.Entry) nextEntry; + } + } + } + + } + + protected static class SetMultimapValueIterator extends AbstractSetMultimapIterator + implements Iterator> { + + SetMultimapValueIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public AbstractSetNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + return specSetNodeOf(currentValueNode.getSingletonValue(currentValueSingletonCursor++)); + } else { + return currentValueNode.getCollectionValue(currentValueCollectionCursor++); + } + } + } + + } + + protected static class SetMultimapNativeTupleIterator + extends AbstractSetMultimapIterator implements Iterator> { + + SetMultimapNativeTupleIterator(AbstractSetMultimapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + final K currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + final Object currentValue = + currentValueNode.getSingletonValue(currentValueSingletonCursor); + currentValueSingletonCursor++; + + return AbstractSpecialisedImmutableMap.entryOf(currentKey, currentValue); + } else { + final K currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + final Object currentValue = + currentValueNode.getCollectionValue(currentValueCollectionCursor); + currentValueCollectionCursor++; + + return AbstractSpecialisedImmutableMap.entryOf(currentKey, currentValue); + } + } + } + + } + + protected static class SetMultimapTupleIterator extends AbstractSetMultimapIterator + implements Iterator { + + final BiFunction tupleOf; + + K currentKey = null; + V currentValue = null; + Iterator currentSetIterator = Collections.emptyIterator(); + + SetMultimapTupleIterator(AbstractSetMultimapNode rootNode, + final BiFunction tupleOf) { + super(rootNode); + this.tupleOf = tupleOf; + } + + @Override + public boolean hasNext() { + if (currentSetIterator.hasNext()) { + return true; + } else { + if (super.hasNext()) { + // TODO: check case distinction + if (currentValueSingletonCursor < currentValueSingletonLength) { + currentKey = currentValueNode.getSingletonKey(currentValueSingletonCursor); + currentSetIterator = Collections + .singleton(currentValueNode.getSingletonValue(currentValueSingletonCursor)) + .iterator(); + currentValueSingletonCursor++; + } else { + currentKey = currentValueNode.getCollectionKey(currentValueCollectionCursor); + currentSetIterator = + currentValueNode.getCollectionValue(currentValueCollectionCursor).iterator(); + currentValueCollectionCursor++; + } + + return true; + } else { + return false; + } + } + } + + @Override + public T next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + currentValue = currentSetIterator.next(); + return tupleOf.apply(currentKey, currentValue); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieSetMultimap_BleedingEdgeNodeIterator + implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieSetMultimap_BleedingEdgeNodeIterator(AbstractSetMultimapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractSetMultimapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractSetMultimapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieSetMultimap_BleedingEdge + implements SetMultimap.Transient { + + private final EqualityComparator cmp; + + final private AtomicReference mutator; + private AbstractSetMultimapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieSetMultimap_BleedingEdge( + TrieSetMultimap_HHAMT_Specialized_Path_Interlinked trieSetMultimap_BleedingEdge) { + this.cmp = trieSetMultimap_BleedingEdge.cmp; + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieSetMultimap_BleedingEdge.rootNode; + this.hashCode = trieSetMultimap_BleedingEdge.hashCode; + this.cachedSize = trieSetMultimap_BleedingEdge.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.equals(iterator.next(), o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsEntry(final Object o0, final Object o1) { + try { + final K key = (K) o0; + final V val = (V) o1; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get().contains(val, val.hashCode(), 0); + } else { + return false; + } + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable get(final Object o) { + try { + final K key = (K) o; + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return setFromNode(result.get()); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public boolean __insert(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.inserted(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean union(final SetMultimap setMultimap) { + boolean modified = false; + + for (Map.Entry entry : setMultimap.entrySet()) { + modified |= this.__insert(entry.getKey(), entry.getValue()); + } + + return modified; + } + + @Override + public boolean __remove(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetMultimapResult details = SetMultimapResult.unchanged(); + + final CompactSetMultimapNode newRootNode = + rootNode.removed(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return false; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new TransientSetMultimapKeyIterator<>(this); + } + + @Override + public Iterator valueIterator() { + return valueCollectionsStream().flatMap(AbstractSetNode::stream).iterator(); + } + + @Override + public Iterator> entryIterator() { + return new TransientSetMultimapTupleIterator<>(this, + AbstractSpecialisedImmutableMap::entryOf); + } + + @Override + public Iterator tupleIterator(final BiFunction tupleOf) { + return new TransientSetMultimapTupleIterator<>(this, tupleOf); + } + + private Spliterator> valueCollectionsSpliterator() { + /* + * TODO: specialize between mutable / SetMultimap.Immutable ({@see Spliterator.IMMUTABLE}) + */ + int characteristics = Spliterator.NONNULL | Spliterator.SIZED | Spliterator.SUBSIZED; + return Spliterators.spliterator(new SetMultimapValueIterator<>(rootNode), size(), + characteristics); + } + + private Stream> valueCollectionsStream() { + boolean isParallel = false; + return StreamSupport.stream(valueCollectionsSpliterator(), isParallel); + } + + public static class TransientSetMultimapKeyIterator extends SetMultimapKeyIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + K lastKey; + + public TransientSetMultimapKeyIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapValueIterator + extends SetMultimapValueIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapValueIterator( + final TransientTrieSetMultimap_BleedingEdge collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public AbstractSetNode next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientSetMultimapTupleIterator + extends SetMultimapTupleIterator { + + final TransientTrieSetMultimap_BleedingEdge collection; + + public TransientSetMultimapTupleIterator( + final TransientTrieSetMultimap_BleedingEdge collection, + final BiFunction tupleOf) { + super(collection.rootNode, tupleOf); + this.collection = collection; + } + + @Override + public T next() { + return super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(currentKey, currentValue); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.sizeDistinct(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieSetMultimap_BleedingEdge.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieSetMultimap_BleedingEdge.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieSetMultimap_BleedingEdge.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieSetMultimap_BleedingEdge.this.isEmpty(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieSetMultimap_BleedingEdge.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieSetMultimap_BleedingEdge) { + TransientTrieSetMultimap_BleedingEdge that = + (TransientTrieSetMultimap_BleedingEdge) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof SetMultimap) { + SetMultimap that = (SetMultimap) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional> result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (!result.isPresent()) { + return false; + } else { + final AbstractSetNode valColl = (AbstractSetNode) entry.getValue(); + + if (!cmp.equals(result.get(), valColl)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public SetMultimap.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieSetMultimap_HHAMT_Specialized_Path_Interlinked(cmp, rootNode, hashCode, + cachedSize); + } + } + + private abstract static class DataLayoutHelper extends CompactSetMultimapNode { + + private static final long[] arrayOffsets = + arrayOffsets(DataLayoutHelper.class, new String[]{"slot0", "slot1"}); + + public final Object slot0 = null; + + public final Object slot1 = null; + + private DataLayoutHelper() { + super(null, 0L); + } + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/ordered/OrderedTrieMap.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/ordered/OrderedTrieMap.java new file mode 100644 index 0000000..3d6e663 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/ordered/OrderedTrieMap.java @@ -0,0 +1,1708 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.ordered; + +import java.lang.ref.SoftReference; +import java.util.Arrays; +import java.util.Comparator; +import java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Optional; + +import io.usethesource.capsule.api.experimental.Map; +import io.usethesource.capsule.util.iterator.SupplierIterator; + +import static java.lang.System.arraycopy; + +/** + * Immutable insertion-ordered map implemented as a hash trie. + * + * NOTE: this is currently the sketch of an implementation that is not yet fully implemented. + */ +public final class OrderedTrieMap implements Map.Immutable { + + private static final Node EMPTY_NODE = new BitmapIndexedNode(0, 0, new Object[]{}); + + private static final OrderedTrieMap EMPTY_MAP = new OrderedTrieMap(EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final Node rootNode; + private final int cachedSize; + + /* + * This field and subsequent IDs stored in nodes are not part of the object identity. + */ + private final int nextSequenceId; + + private static final boolean INSERTION_ORDER_CACHING_ENABLED = true; + + private static final int INSERTION_ORDER_CACHING_THRESHOLD = 8; + + SoftReference[]> cachedInsertionOrderSequence; + + private OrderedTrieMap(Node rootNode, int cachedSize, int nextSequenceId) { + this.rootNode = rootNode; + this.cachedSize = cachedSize; + + this.nextSequenceId = nextSequenceId; + + if (DEBUG) { + assert checkSize(cachedSize); + } + } + + public static final OrderedTrieMap of() { + return (OrderedTrieMap) EMPTY_MAP; + } + + private boolean checkSize(final int targetSize) { + int size = 0; + + for (Iterator it = new ValueIterator<>(rootNode); it.hasNext(); size++) { + } + + return size == targetSize; + } + + @Deprecated + public java.util.Map.Entry getLastEntry() { + ImmutablePayloadTuple[] sortedEntries = getAndCacheSortedEntryArray(); + return sortedEntries[cachedSize - 1]; + } + + private static final K extractKey(final ImmutablePayloadTuple tuple) { + return tuple.getKey(); + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean contains(final Object key) { + try { + final int keyHash = key.hashCode(); + + return rootNode.containsKey(key, transformHashCode(keyHash), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + @Override + public java.util.Optional apply(K key) { + final int keyHash = key.hashCode(); + return rootNode.find(key, transformHashCode(keyHash), 0).map(java.util.Map.Entry::getValue); + } + + private V get(final Object key) { + try { + final int keyHash = key.hashCode(); + final Optional result = + rootNode.find(key, transformHashCode(keyHash), 0).map(java.util.Map.Entry::getValue); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public OrderedTrieMap insert(K key, V val) { + final int keyHash = key.hashCode(); + final UpdateReport report = new UpdateReport(); + + final ImmutablePayloadTuple payloadTuple = + ImmutablePayloadTuple.of(nextSequenceId, key, val, transformHashCode(keyHash)); + + final Node newRootNode = + rootNode.updated(payloadTuple, transformHashCode(keyHash), 0, report); + + if (report.isTrieModified()) { + // invalidate cache + cachedInsertionOrderSequence = null; + + if (report.isTrieElementReplaced()) { + return new OrderedTrieMap<>(newRootNode, cachedSize, nextSequenceId); + } else { + return new OrderedTrieMap<>(newRootNode, cachedSize + 1, nextSequenceId + 1); + } + } + + return this; + } + + @Override + public OrderedTrieMap remove(K key) { + final int keyHash = key.hashCode(); + final UpdateReport report = new UpdateReport(); + + final Node newRootNode = rootNode.removed(key, transformHashCode(keyHash), 0, report); + + if (report.isTrieModified()) { + // invalidate cache + cachedInsertionOrderSequence = null; + + return new OrderedTrieMap<>(newRootNode, cachedSize - 1, nextSequenceId); + } + + return this; + } + + @Override + public long size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + /** + * Key iterator that ignores insertion order and consequently yields better performance. + */ + public Iterator keyIterator() { + return new KeyIterator<>(rootNode); + } + + /** + * Key iterator that ignores insertion order and consequently yields better performance. + */ + public Iterator valueIterator() { + return new ValueIterator<>(rootNode); + } + + @Override + public Iterator> entryIterator() { + return (Iterator) new EntryIterator<>(rootNode); + } + + public Iterator orderedKeyIterator() { + return new ForwardKeyIterator<>(getAndCacheSortedEntryArray()); + } + + public Iterator orderedValueIterator() { + return new ForwardElementIterator<>(getAndCacheSortedEntryArray()); + } + + public Iterator> unorderedTupleIterator() { + return new EntryIterator<>(rootNode); + } + + public Iterator> orderedEntryIterator() { + return new ForwardEntryIterator<>(getAndCacheSortedEntryArray()); + } + + public Iterator reverseOrderedKeyIterator() { + return new ReverseKeyIterator<>(getAndCacheSortedEntryArray()); + } + + public Iterator reverseOrderedValueIterator() { + return new ReverseValueIterator<>(getAndCacheSortedEntryArray()); + } + + public Iterator> reverseOrderedEntryIterator() { + return new ReverseEntryIterator<>(getAndCacheSortedEntryArray()); + } + + // @Override + // public Set keySet() { + // Set keySet = null; + // + // if (keySet == null) { + // keySet = new AbstractSet() { + // @Override + // public Iterator iterator() { + // return OrderedTrieMap.this.orderedKeyIterator(); + // } + // + // @Override + // public int size() { + // return OrderedTrieMap.this.size(); + // } + // + // @Override + // public boolean isEmpty() { + // return OrderedTrieMap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // OrderedTrieMap.this.clear(); + // } + // + // @Override + // public boolean contains(Object key) { + // return OrderedTrieMap.this.containsKey(key); + // } + // }; + // } + // + // return keySet; + // } + + // @Override + // public Collection values() { + // Collection values = null; + // + // if (values == null) { + // values = new AbstractCollection() { + // @Override + // public Iterator iterator() { + // return OrderedTrieMap.this.orderedValueIterator(); + // } + // + // @Override + // public int size() { + // return OrderedTrieMap.this.size(); + // } + // + // @Override + // public boolean isEmpty() { + // return OrderedTrieMap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // OrderedTrieMap.this.clear(); + // } + // + // @Override + // public boolean contains(Object value) { + // return OrderedTrieMap.this.containsValue(value); + // } + // }; + // } + // + // return values; + // } + + // @Override + // public Set> entrySet() { + // Set> entrySet = null; + // + // if (entrySet == null) { + // entrySet = new AbstractSet>() { + // @Override + // public Iterator> iterator() { + // return OrderedTrieMap.this.entryIterator(); + // } + // + // @Override + // public int size() { + // return OrderedTrieMap.this.size(); + // } + // + // @Override + // public boolean isEmpty() { + // return OrderedTrieMap.this.isEmpty(); + // } + // + // @Override + // public void clear() { + // OrderedTrieMap.this.clear(); + // } + // + // @Override + // public boolean contains(Object key) { + // return OrderedTrieMap.this.containsKey(key); + // } + // }; + // } + // + // return entrySet; + // } + + @Override + public int hashCode() { + int hash = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final java.util.Map.Entry entry = it.next(); + hash += entry.hashCode(); + } + + return hash; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + if (getClass() != other.getClass()) { + return false; + } + + OrderedTrieMap that = (OrderedTrieMap) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + return rootNode.equals(that.rootNode); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('{'); + + if (cachedSize > 1) { + Iterator> it = entryIterator(); + + // append head + bldr.append(it.next()); + + // append tail + while (it.hasNext()) { + bldr.append(", "); + bldr.append(it.next()); + } + } + + bldr.append('}'); + return bldr.toString(); + } + + private ImmutablePayloadTuple[] toSortedEntryArray() { + final ImmutablePayloadTuple[] arr = new ImmutablePayloadTuple[cachedSize]; + + Iterator> it = unorderedTupleIterator(); + + for (int i = 0; i < cachedSize; i++) { + assert it.hasNext(); + arr[i] = it.next(); + } + + Arrays.sort(arr, ImmutablePayloadTuple.ASCENDING_COMPARATOR); + + return arr; + } + + private ImmutablePayloadTuple[] getAndCacheSortedEntryArray() { + ImmutablePayloadTuple[] arr = + cachedInsertionOrderSequence == null ? null : cachedInsertionOrderSequence.get(); + + if (arr == null) { + arr = toSortedEntryArray(); + + if (INSERTION_ORDER_CACHING_ENABLED && cachedSize > INSERTION_ORDER_CACHING_THRESHOLD) { + cachedInsertionOrderSequence = + new SoftReference[]>(arr); + } + } + + return arr; + } + + private static final class UpdateReport { + + private boolean isModified; + private boolean isElementReplaced; + + // // update: neither element, nor element count changed + public UpdateReport() { + this.isModified = false; + this.isElementReplaced = false; + } + + // update: inserted/removed single element, element count changed + public void setTrieModified() { + this.isModified = true; + this.isElementReplaced = false; + } + + public boolean isTrieModified() { + return isModified; + } + + public void setTrieElementReplaced() { + this.isModified = true; + this.isElementReplaced = true; + } + + public boolean isTrieElementReplaced() { + return isElementReplaced; + } + } + + static interface Node { + + boolean containsKey(final Object key, final int keyHash, final int shift); + + // boolean containsValue(final V val, final int keyHash, final int shift); + + Optional> find(final Object key, final int keyHash, final int shift); + + Node updated(ImmutablePayloadTuple payloadTuple, final int keyHash, final int shift, + final UpdateReport report); + + Node removed(final Object key, final int keyHash, final int shift, + final UpdateReport report); + + boolean hasNodes(); + + int nodeArity(); + + Node getNode(final int index); + + boolean hasElements(); + + int elementArity(); + + ImmutablePayloadTuple getElement(final int index); + + Object getKey(final int index); + + int getSequenceId(final int index); + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + byte sizePredicate(); + + } + + private static final class BitmapIndexedNode implements Node { + + private final int nodeMap; + private final int dataMap; + + private final Object[] nodes; + + private BitmapIndexedNode(final int nodeMap, final int dataMap, final Object[] nodes) { + + this.nodeMap = nodeMap; + this.dataMap = dataMap; + + this.nodes = nodes; + + if (DEBUG) { + + assert (java.lang.Integer.bitCount(dataMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < elementArity(); i++) { + assert ((nodes[i] instanceof Node) == false); + } + for (int i = elementArity(); i < nodes.length; i++) { + assert ((nodes[i] instanceof Node) == true); + } + } + + assert nodeInvariant(); + } + + static final BitmapIndexedNode newElementSingleton(int dataMap, + java.util.Map.Entry element0) { + return new BitmapIndexedNode<>(0, dataMap, new Object[]{element0}); + } + + static final BitmapIndexedNode newElementTuple(int dataMap, + java.util.Map.Entry element0, java.util.Map.Entry element1) { + return new BitmapIndexedNode<>(0, dataMap, new Object[]{element0, element1}); + } + + static final BitmapIndexedNode newSubnodeSingleton(int nodeMap, + Node subNode) { + return new BitmapIndexedNode<>(nodeMap, 0, new Object[]{subNode}); + } + + @Deprecated + // Only used in nodeInvariant() + int arity() { + return elementArity() + nodeArity(); + } + + @Deprecated + // Only used in nodeInvariant() + int size() { + final Iterator it = new ValueIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + + boolean nodeInvariant() { + boolean inv1 = (size() - elementArity() >= 2 * (arity() - elementArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + boolean inv3 = + (this.arity() == 1 && elementArity() == 1) ? sizePredicate() == SIZE_ONE : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + + boolean inv5 = (this.nodeArity() >= 0) && (this.elementArity() >= 0) + && ((this.elementArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + @Override + public ImmutablePayloadTuple getElement(final int index) { + return (ImmutablePayloadTuple) nodes[index]; + } + + @Override + public K getKey(final int index) { + return extractKey(getElement(index)); + } + + @Override + public int getSequenceId(final int index) { + return getElement(index).sequenceId; + } + + @Override + public Node getNode(final int index) { + return (Node) nodes[nodes.length - 1 - index]; + } + + @Override + public boolean hasElements() { + return dataMap != 0; + } + + @Override + public int elementArity() { + return (dataMap == 0) ? 0 : java.lang.Integer.bitCount(dataMap); + } + + @Override + public boolean hasNodes() { + return nodeMap != 0; + } + + @Override + public int nodeArity() { + return (nodeMap == 0) ? 0 : java.lang.Integer.bitCount(nodeMap); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + (nodeMap); + result = prime * result + (dataMap); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedNode that = (BitmapIndexedNode) other; + if (nodeMap != that.nodeMap) { + return false; + } + if (dataMap != that.dataMap) { + return false; + } + if (!Arrays.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + private static byte recoverMask(int bitmap, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + int map = bitmap; + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = map >> 1; + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < elementArity(); i++) { + final byte pos = recoverMask(dataMap, (byte) (i + 1)); + bldr.append(String.format("@%d<#%d>", pos, Objects.hashCode(extractKey(getElement(i))))); + + if (!((i + 1) == elementArity())) { + bldr.append(", "); + } + } + + if (elementArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap, (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + @Override + public byte sizePredicate() { + if (this.nodeArity() == 0) { + switch (this.elementArity()) { + case 0: + return SIZE_EMPTY; + case 1: + return SIZE_ONE; + default: + return SIZE_MORE_THAN_ONE; + } + } else { + return SIZE_MORE_THAN_ONE; + } + } + + Node copyAndSetNode(final int bitpos, final Node node) { + final int idx = this.nodes.length - 1 - index(nodeMap, bitpos); + + final Object[] newNodes = new Object[nodes.length]; + + // copy 'nodes' and update 1 element(s) at position 'idx' + arraycopy(nodes, 0, newNodes, 0, nodes.length); + newNodes[idx] = node; + + return new BitmapIndexedNode<>(nodeMap, dataMap, newNodes); + } + + Node copyAndInsertValue(final int bitpos, final ImmutablePayloadTuple element) { + final int idx = index(dataMap, bitpos); + + final Object[] newNodes = new Object[nodes.length + 1]; + + // copy 'nodes' and insert 1 element(s) at position 'idx' + arraycopy(nodes, 0, newNodes, 0, idx); + newNodes[idx] = element; + arraycopy(nodes, idx, newNodes, idx + 1, nodes.length - idx); + + return new BitmapIndexedNode<>(nodeMap, dataMap | bitpos, newNodes); + } + + Node copyAndSetValue(final int bitpos, final ImmutablePayloadTuple element) { + final int idx = index(dataMap, bitpos); + + final Object[] newNodes = new Object[nodes.length]; + + // copy 'nodes' and set element(s) at position 'idx' + arraycopy(nodes, 0, newNodes, 0, nodes.length); + newNodes[idx] = element; + + return new BitmapIndexedNode<>(nodeMap, dataMap, newNodes); + } + + Node copyAndRemoveValue(final int bitpos) { + final int idx = index(dataMap, bitpos); + + final Object[] newNodes = new Object[nodes.length - 1]; + + // copy 'nodes' and remove 1 element(s) at position 'idx' + arraycopy(nodes, 0, newNodes, 0, idx); + arraycopy(nodes, idx + 1, newNodes, idx, nodes.length - idx - 1); + + return new BitmapIndexedNode<>(nodeMap, dataMap ^ bitpos, newNodes); + } + + Node copyAndMigrateFromInlineToNode(final int bitpos, final Node node) { + + final int idxOld = index(dataMap, bitpos); + final int idxNew = nodes.length - 1 - index(nodeMap, bitpos); + + final Object[] newNodes = new Object[nodes.length]; + + // copy 'nodes' and remove 1 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' + assert idxOld <= idxNew; + arraycopy(nodes, 0, newNodes, 0, idxOld); + arraycopy(nodes, idxOld + 1, newNodes, idxOld, idxNew - idxOld); + newNodes[idxNew] = node; + arraycopy(nodes, idxNew + 1, newNodes, idxNew + 1, nodes.length - idxNew - 1); + + return new BitmapIndexedNode<>(nodeMap | bitpos, dataMap ^ bitpos, newNodes); + } + + Node copyAndMigrateFromNodeToInline(final int bitpos, final Node node) { + + final int idxOld = nodes.length - 1 - index(nodeMap, bitpos); + final int idxNew = index(dataMap, bitpos); + + final Object[] newNodes = new Object[nodes.length]; + + // copy 'nodes' and remove 1 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' + assert idxOld >= idxNew; + arraycopy(nodes, 0, newNodes, 0, idxNew); + newNodes[idxNew] = node.getElement(0); + arraycopy(nodes, idxNew, newNodes, idxNew + 1, idxOld - idxNew); + arraycopy(nodes, idxOld + 1, newNodes, idxOld + 1, nodes.length - idxOld - 1); + + return new BitmapIndexedNode<>(nodeMap ^ bitpos, dataMap | bitpos, newNodes); + } + + @Override + public boolean containsKey(final Object key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index).equals(key); + } + + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + bitPartitionSize()); + } + + return false; + } + + // @Override + // public boolean containsValue(final ImmutableMapEntry element, final int keyHash, final + // int shift) { + // final int mask = mask(keyHash, shift); + // final int bitpos = bitpos(mask); + // + // if ((dataMap & bitpos) != 0) { + // final int index = index(dataMap, mask, bitpos); + // return getElement(index).equals(element); + // } + // + // if ((nodeMap & bitpos) != 0) { + // final int index = index(nodeMap, mask, bitpos); + // return getNode(index).containsValue(element, keyHash, shift + bitPartitionSize()); + // } + // + // return false; + // } + + @Override + public Optional> find(final Object key, final int keyHash, + final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + if (getKey(index).equals(key)) { + return Optional.of(getElement(index)); + } + + return Optional.empty(); + } + + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).find(key, keyHash, shift + bitPartitionSize()); + } + + return Optional.empty(); + } + + @Override + public Node updated(ImmutablePayloadTuple newTuple, final int keyHash, + final int shift, final UpdateReport report) { + + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap & bitpos) != 0) { // inplace value + final int dataIndex = index(dataMap, bitpos); + final ImmutablePayloadTuple currentTuple = getElement(dataIndex); + + if (currentTuple.getKey().equals(newTuple.getKey())) { + // update mapping + report.setTrieElementReplaced(); + return copyAndSetValue(bitpos, currentTuple.withUpdatedValue(newTuple.getValue())); + } else { + final int currentKeyHash = getKey(dataIndex).hashCode(); + final int currentSequenceId = getSequenceId(dataIndex); + + final Node subNodeNew = mergeTwoElements(currentTuple, + transformHashCode(currentKeyHash), newTuple, keyHash, shift + bitPartitionSize()); + + report.setTrieModified(); + return copyAndMigrateFromInlineToNode(bitpos, subNodeNew); + } + } else if ((nodeMap & bitpos) != 0) { // node (not value) + final int nodeIndex = index(nodeMap, bitpos); + + final Node subNode = getNode(nodeIndex); + final Node subNodeNew = + subNode.updated(newTuple, keyHash, shift + bitPartitionSize(), report); + + if (report.isTrieModified()) { + return copyAndSetNode(bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + report.setTrieModified(); + return copyAndInsertValue(bitpos, newTuple); + } + } + + @Override + public Node removed(final Object key, final int keyHash, final int shift, + final UpdateReport report) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap & bitpos) != 0) { // inplace value + final int dataIndex = index(dataMap, bitpos); + + if (getKey(dataIndex).equals(key)) { + report.setTrieModified(); + + if (this.elementArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = (shift == 0) ? dataMap ^ bitpos : bitpos(mask(keyHash, 0)); + + return BitmapIndexedNode.newElementSingleton(newDataMap, getElement(1 - dataIndex)); + } else { + return copyAndRemoveValue(bitpos); + } + } else { + return this; + } + } else if ((nodeMap & bitpos) != 0) { // node (not value) + final int nodeIndex = index(nodeMap, bitpos); + + final Node subNode = getNode(nodeIndex); + final Node subNodeNew = + subNode.removed(key, keyHash, shift + bitPartitionSize(), report); + + if (!report.isTrieModified()) { + return this; + } + + if (subNodeNew.sizePredicate() == SIZE_ONE) { + if (this.elementArity() == 0 && this.nodeArity() == 1) { + // escalate (singleton or empty) result + return subNodeNew; + } else { + // inline value (move to front) + return copyAndMigrateFromNodeToInline(bitpos, subNodeNew); + } + } else { + assert subNode.sizePredicate() == SIZE_MORE_THAN_ONE; + + // modify current node (set replacement node) + return copyAndSetNode(bitpos, subNodeNew); + } + } else { + // no value + return this; + } + } + + /*************************/ + /*** UTILITY FUNCTIONS ***/ + /*************************/ + + static final int hashCodeLength() { + return 32; + } + + static final int bitPartitionSize() { + return 5; + } + + static final int bitPartitionMask() { + return 0b11111; + } + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & bitPartitionMask(); + } + + static final int bitpos(final int mask) { + return 1 << mask; + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + static final Node mergeTwoElements(final ImmutablePayloadTuple element0, + final int keyHash0, final ImmutablePayloadTuple element1, final int keyHash1, + final int shift) { + Object key0 = extractKey(element0); + Object key1 = extractKey(element1); + assert !(key0.equals(key1)); + + if (shift >= hashCodeLength()) { + return new HashCollisionNode<>(keyHash0, element0, element1); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int dataMap = bitpos(mask0) | bitpos(mask1); + + if (mask0 < mask1) { + return BitmapIndexedNode.newElementTuple(dataMap, element0, element1); + } else { + return BitmapIndexedNode.newElementTuple(dataMap, element1, element0); + } + } else { + final Node node = + mergeTwoElements(element0, keyHash0, element1, keyHash1, shift + bitPartitionSize()); + // values fit on next level + final int nodeMap = bitpos(mask0); + + return BitmapIndexedNode.newSubnodeSingleton(nodeMap, node); + } + } + + } + + private static final class HashCollisionNode implements Node { + + private final int hash; + private final ImmutablePayloadTuple[] elements; + + private HashCollisionNode(final int hash, final ImmutablePayloadTuple element0, + final ImmutablePayloadTuple element1) { + this.hash = hash; + + this.elements = newElementArray(element0, element1); + } + + private HashCollisionNode(final int hash, final ImmutablePayloadTuple[] elements) { + if (elements.length <= 2) { + throw new IllegalArgumentException("At least two elements are required."); + } + this.hash = hash; + this.elements = elements; + } + + /* + * TODO: find a right place for this utility method. + */ + @SafeVarargs + private static final ImmutablePayloadTuple[] newElementArray( + ImmutablePayloadTuple... elements) { + return elements; + } + + /* + * TODO: find a right place for this utility method. + */ + private static final ImmutablePayloadTuple[] newElementArray(int size) { + return new ImmutablePayloadTuple[size]; + } + + @Override + public boolean containsKey(final Object key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (ImmutablePayloadTuple e : elements) { + if (extractKey(e).equals(key)) { + return true; + } + } + } + return false; + } + + // @Override + // public boolean containsValue(final Property element, final int keyHash, final int shift) { + // if (this.hash == keyHash) { + // for (Property e : elements) + // if (e.equals(element)) + // return true; + // } + // return false; + // } + + @Override + public Optional> find(final Object key, final int keyHash, + final int shift) { + if (this.hash == keyHash) { + for (ImmutablePayloadTuple e : elements) { + if (extractKey(e).equals(key)) { + return Optional.of(e); + } + } + } + return Optional.empty(); + } + + @Override + public Node updated(ImmutablePayloadTuple newTuple, final int keyHash, + final int shift, final UpdateReport report) { + assert this.hash == keyHash; + + int indexOfKey = -1; + + for (int i = 0; i < elementArity() && indexOfKey == -1; i++) { + final ImmutablePayloadTuple currentTuple = getElement(i); + + if (currentTuple.getKey().equals(newTuple.getKey())) { + indexOfKey = i; + } + } + + if (indexOfKey == -1) { + // insert + final ImmutablePayloadTuple[] extendedElements = newElementArray(elements.length + 1); + arraycopy(elements, 0, extendedElements, 0, elements.length); + extendedElements[elements.length] = newTuple; + + report.setTrieModified(); + return new HashCollisionNode<>(keyHash, extendedElements); + } else { + // replace + final ImmutablePayloadTuple[] extendedElements = newElementArray(elements.length); + arraycopy(elements, 0, extendedElements, 0, elements.length); + extendedElements[indexOfKey] = newTuple; + + report.setTrieElementReplaced(); + return new HashCollisionNode<>(keyHash, extendedElements); + } + } + + @Override + public Node removed(final Object key, final int keyHash, final int shift, + final UpdateReport report) { + assert this.hash == keyHash; + + int indexOfKey = -1; + + for (int i = 0; i < elementArity() && indexOfKey == -1; i++) { + if (getKey(i).equals(key)) { + indexOfKey = i; + } + } + + if (indexOfKey == -1) { + return this; + } else { + if (elements.length == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final int dataMap = BitmapIndexedNode.bitpos(BitmapIndexedNode.mask(hash, 0)); + /* + * TODO: create Utils class for utility functions that are currenlty in BitmapIndexedNode + * (see usage above) + */ + + report.setTrieModified(); + return BitmapIndexedNode.newElementSingleton(dataMap, elements[1 - indexOfKey]); + } else { + final ImmutablePayloadTuple[] reducedElements = + newElementArray(elements.length - 1); + arraycopy(elements, 0, reducedElements, 0, indexOfKey); + arraycopy(elements, indexOfKey + 1, reducedElements, indexOfKey, + elements.length - indexOfKey - 1); + + report.setTrieModified(); + return new HashCollisionNode<>(keyHash, reducedElements); + } + } + } + + @Override + public boolean hasElements() { + return true; + } + + @Override + public int elementArity() { + return elements.length; + } + + @Override + public boolean hasNodes() { + return false; + } + + @Override + public int nodeArity() { + return 0; + } + + @Override + public byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + public ImmutablePayloadTuple getElement(final int index) { + return elements[index]; + } + + @Override + public Object getKey(final int index) { + return extractKey(getElement(index)); + } + + @Override + public int getSequenceId(final int index) { + return elements[index].sequenceId; + } + + @Override + public Node getNode(int index) { + throw new UnsupportedOperationException( + "Hash collision nodes are leaf nodes, without further sub-trees."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + hash; + result = prime * result + Arrays.hashCode(elements); + return result; + } + + @Override + public boolean equals(Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + HashCollisionNode that = (HashCollisionNode) other; + + if (hash != that.hash) { + return false; + } + + if (elementArity() != that.elementArity()) { + return false; + } + + /* + * Linear scan for each element, because of arbitrary element order. + */ + outerLoop: + for (ImmutablePayloadTuple e1 : elements) { + innerLoop: + for (ImmutablePayloadTuple e2 : that.elements) { + if (e1.equals(e2)) { + continue outerLoop; + } + } + return false; + } + + return true; + } + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected Node currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + Node[] nodes = new Node[MAX_DEPTH]; + + AbstractIterator(Node rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasElements()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.elementArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final Node nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasElements()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.elementArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + private static final class KeyIterator extends AbstractIterator + implements Iterator { + + KeyIterator(Node rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getElement(currentValueCursor++).getKey(); + } + } + } + + private static final class ValueIterator extends AbstractIterator + implements Iterator { + + ValueIterator(Node rootNode) { + super(rootNode); + } + + @Override + public V next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getElement(currentValueCursor++).getValue(); + } + } + } + + private static final class EntryIterator extends AbstractIterator + implements Iterator> { + + EntryIterator(Node rootNode) { + super(rootNode); + } + + @Override + public ImmutablePayloadTuple next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getElement(currentValueCursor++); + + // return new ImmutableMapEntry(currentValueNode.getSequenceId(currentValueCursor), + // currentValueNode.getKey(currentValueCursor), + // currentValueNode.getVal(currentValueCursor++)); + } + } + } + + protected static class ImmutablePayloadTuple + implements java.util.Map.Entry, Comparable> { + + private final int sequenceId; + private final K key; + private final V val; + + private ImmutablePayloadTuple(final int sequenceId, final K key, final V val) { + this.sequenceId = sequenceId; + this.key = key; + this.val = val; + } + + static final ImmutablePayloadTuple of(final int sequenceId, final K key, + final V val, final int keyHash) { + return new ImmutablePayloadTuple(sequenceId, key, val); + } + + @Override + public K getKey() { + return key; + } + + @Override + public V getValue() { + return val; + } + + @Override + public V setValue(V value) { + throw new UnsupportedOperationException(); + } + + // public ImmutableMapEntry withUpdatedKey(K key) { + // return new ImmutableMapEntry<>(sequenceId, key, val); + // } + + public ImmutablePayloadTuple withUpdatedValue(V val) { + return new ImmutablePayloadTuple<>(sequenceId, key, val); + } + + @Override + public int compareTo(ImmutablePayloadTuple other) { + return sequenceId - other.sequenceId; + } + + @Override + public int hashCode() { + return getKey().hashCode() ^ getValue().hashCode(); + } + + @Override + public boolean equals(Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + ImmutablePayloadTuple that = (ImmutablePayloadTuple) other; + + return Objects.equals(key, that.key) && Objects.equals(val, that.val); + } + + @Override + public String toString() { + return String.format("%s=%s", getKey(), getValue()); + } + + protected static final Comparator> ASCENDING_COMPARATOR = + (o1, o2) -> o1.sequenceId - o2.sequenceId; + + protected static final Comparator> DESCENDING_COMPARATOR = + (o1, o2) -> o2.sequenceId - o1.sequenceId; + + } + + private static abstract class AbstractForwardOrderArrayIterator implements Iterator { + + final E[] values; + final int end; + int currentIndex; + + public AbstractForwardOrderArrayIterator(final E[] values, int start, int end) { + assert start >= 0 && start <= end && end < values.length; + + this.values = values; + this.end = end; + this.currentIndex = start; + } + + @Override + public boolean hasNext() { + return currentIndex <= end; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + private static final class ForwardKeyIterator + extends AbstractForwardOrderArrayIterator, K> { + + ForwardKeyIterator(ImmutablePayloadTuple[] arr) { + super(arr, 0, arr.length - 1); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return values[currentIndex++].getKey(); + } + } + } + + private static final class ForwardElementIterator + extends AbstractForwardOrderArrayIterator, V> { + + ForwardElementIterator(ImmutablePayloadTuple[] arr) { + super(arr, 0, arr.length - 1); + } + + @Override + public V next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return values[currentIndex++].getValue(); + } + } + } + + private static final class ForwardEntryIterator extends + AbstractForwardOrderArrayIterator, ImmutablePayloadTuple> { + + ForwardEntryIterator(ImmutablePayloadTuple[] arr) { + super(arr, 0, arr.length - 1); + } + + @Override + public ImmutablePayloadTuple next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return values[currentIndex++]; + } + } + } + + private static abstract class AbstractReversedOrderArrayIterator implements Iterator { + + final E[] values; + final int end; + int currentIndex; + + public AbstractReversedOrderArrayIterator(final E[] values, int start, int end) { + assert end >= 0 && end <= start && start < values.length; + + this.values = values; + this.end = end; + this.currentIndex = start; + } + + @Override + public boolean hasNext() { + return currentIndex >= end; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + private static final class ReverseKeyIterator + extends AbstractReversedOrderArrayIterator, K> { + + ReverseKeyIterator(ImmutablePayloadTuple[] arr) { + super(arr, arr.length - 1, 0); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return values[currentIndex--].getKey(); + } + } + } + + private static final class ReverseValueIterator + extends AbstractReversedOrderArrayIterator, V> { + + ReverseValueIterator(ImmutablePayloadTuple[] arr) { + super(arr, arr.length - 1, 0); + } + + @Override + public V next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return values[currentIndex--].getValue(); + } + } + } + + private static final class ReverseElementIterator extends + AbstractReversedOrderArrayIterator, ImmutablePayloadTuple> { + + ReverseElementIterator(ImmutablePayloadTuple[] arr) { + super(arr, arr.length - 1, 0); + } + + @Override + public ImmutablePayloadTuple next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return values[currentIndex--]; + } + } + } + + private static final class ReverseEntryIterator extends + AbstractReversedOrderArrayIterator, ImmutablePayloadTuple> { + + ReverseEntryIterator(ImmutablePayloadTuple[] arr) { + super(arr, arr.length - 1, 0); + } + + @Override + public ImmutablePayloadTuple next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return values[currentIndex--]; + } + } + } + + @Override + public SupplierIterator iterator() { + // TODO Auto-generated method stub + return null; + } + + @Override + public Map.Immutable insertAll(Map map) { + // TODO Auto-generated method stub + return null; + } + + @Override + public Map.Immutable asImmutable() { + return this; + } + + @Override + public boolean isTransientSupported() { + return false; + } + + @Override + public Map.Transient asTransient() { + throw new UnsupportedOperationException("Transient is not supported."); + } + + @Override + public java.util.Map asJdkCollection() { + // TODO Auto-generated method stub + return null; + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/relation/TernaryTrieSetMultimap.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/relation/TernaryTrieSetMultimap.java new file mode 100644 index 0000000..76c77bd --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/relation/TernaryTrieSetMultimap.java @@ -0,0 +1,149 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.relation; + +import java.util.Iterator; +import java.util.function.BiFunction; + +import io.usethesource.capsule.Set; +import io.usethesource.capsule.SetMultimap; +import io.usethesource.capsule.api.TernaryRelation; +import io.usethesource.capsule.api.Triple; +import io.usethesource.capsule.util.collection.AbstractImmutableSet; + +public class TernaryTrieSetMultimap> + extends AbstractImmutableSet implements TernaryRelation.Immutable { + + private final SetMultimap.Immutable indexT; + private final SetMultimap.Immutable indexU; + private final SetMultimap.Immutable indexV; + + public TernaryTrieSetMultimap(final SetMultimap.Immutable indexT, + final SetMultimap.Immutable indexU, final SetMultimap.Immutable indexV) { + this.indexT = indexT; + this.indexU = indexU; + this.indexV = indexV; + } + + public static final > TernaryRelation.Immutable of() { + /* + * NOTE: uses default multi-map to create nested forward and backward maps. + * + * TODO: make classes of nested multi-maps configurable. + */ + return new TernaryTrieSetMultimap<>(SetMultimap.Immutable.of(), SetMultimap.Immutable.of(), + SetMultimap.Immutable.of()); + } + + // @SuppressWarnings("unchecked") + // public static final > TernaryRelation.Transient + // of() { + // /* + // * NOTE: uses default multi-map to create nested forward and backward maps. + // * + // * TODO: make classes of nested multi-maps configurable. + // */ + // return new TransientTernaryTrieSetMultimap<>(SetMultimap.of(), + // SetMultimap.of(), SetMultimap.of()); + // } + + private static > TernaryTrieSetMultimap wireTuple( + R triple, final BiFunction> fstMerger, + final BiFunction> sndMerger, + final BiFunction> trdMerger) { + + return new TernaryTrieSetMultimap(fstMerger.apply(triple._0(), triple), + sndMerger.apply(triple._1(), triple), trdMerger.apply(triple._2(), triple)); + } + + @Override + public int size() { + return indexT.size(); + } + + @Override + public boolean isEmpty() { + return indexT.isEmpty(); + } + + @Override + public boolean contains(Object o) { + try { + final Triple triple = (Triple) o; + return indexT.containsEntry(triple._0(), triple); + } catch (ClassCastException e) { + return false; + } + } + + @Override + public R get(Object o) { + try { + final Triple triple = (Triple) o; + return indexT.get(triple._0()).get(triple); + } catch (ClassCastException e) { + return null; + } + } + + @Override + public Iterator iterator() { + return indexT.valueIterator(); + } + + @Override + public Iterator keyIterator() { + return this.iterator(); + } + + @Override + public TernaryTrieSetMultimap __insert(R triple) { + return wireTuple(triple, indexT::__insert, indexU::__insert, indexV::__insert); + } + + @Override + public TernaryTrieSetMultimap __remove(R triple) { + return wireTuple(triple, indexT::__remove, indexU::__remove, indexV::__remove); + } + + private static final B foldLeft(final B start, final Iterable items, + final BiFunction merger) { + B result = start; + for (A item : items) { + result = merger.apply(result, item); + } + return result; + } + + @Override + public TernaryTrieSetMultimap __insertAll(java.util.Set set) { + /* + * TODO: apply foldLeft to multi-maps before wiring. + */ + return foldLeft(this, set, (xs, y) -> xs.__insert(y)); + } + + @Override + public Set.Immutable __removeAll(java.util.Set set) { + /* + * TODO: apply foldLeft to multi-maps before wiring. + */ + return foldLeft(this, set, (xs, y) -> xs.__remove(y)); + } + + @Override + public Set.Immutable __retainAll(java.util.Set set) { + throw new IllegalStateException("Not yet implemented."); + } + + @Override + public TernaryRelation.Transient asTransient() { + throw new IllegalStateException("Not yet implemented."); + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieMap_5Bits_Spec0To16.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieMap_5Bits_Spec0To16.java new file mode 100644 index 0000000..db78142 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieMap_5Bits_Spec0To16.java @@ -0,0 +1,95355 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.specialized; + +import java.text.DecimalFormat; +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.atomic.AtomicReference; + +import io.usethesource.capsule.Map; +import io.usethesource.capsule.util.iterator.ArrayIterator; + +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +@SuppressWarnings("rawtypes") +public class TrieMap_5Bits_Spec0To16 implements Map.Immutable { + + @SuppressWarnings("unchecked") + private static final TrieMap_5Bits_Spec0To16 EMPTY_MAP = + new TrieMap_5Bits_Spec0To16(CompactMapNode.emptyTrieNodeConstant(), 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractMapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieMap_5Bits_Spec0To16(AbstractMapNode rootNode, int hashCode, int cachedSize) { + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + @SuppressWarnings("unchecked") + public static final Map.Immutable of() { + return TrieMap_5Bits_Spec0To16.EMPTY_MAP; + } + + @SuppressWarnings("unchecked") + public static final Map.Immutable of(Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + Map.Immutable result = TrieMap_5Bits_Spec0To16.EMPTY_MAP; + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final K key = (K) keyValuePairs[i]; + final V val = (V) keyValuePairs[i + 1]; + + result = result.__put(key, val); + } + + return result; + } + + @SuppressWarnings("unchecked") + public static final Map.Transient transientOf() { + return TrieMap_5Bits_Spec0To16.EMPTY_MAP.asTransient(); + } + + @SuppressWarnings("unchecked") + public static final Map.Transient transientOf(Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + final Map.Transient result = TrieMap_5Bits_Spec0To16.EMPTY_MAP.asTransient(); + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final K key = (K) keyValuePairs[i]; + final V val = (V) keyValuePairs[i + 1]; + + result.__put(key, val); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext();) { + final java.util.Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + public boolean containsKey(final Object o) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + public V get(final Object o) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public V getEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public Map.Immutable __put(final K key, final V val) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieMap_5Bits_Spec0To16(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val.hashCode(); + return new TrieMap_5Bits_Spec0To16(newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1); + } + + return this; + } + + public Map.Immutable __putEquivalent(final K key, final V val, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieMap_5Bits_Spec0To16(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val.hashCode(); + return new TrieMap_5Bits_Spec0To16(newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1); + } + + return this; + } + + public Map.Immutable __putAll(final java.util.Map map) { + final Map.Transient tmpTransient = this.asTransient(); + tmpTransient.__putAll(map); + return tmpTransient.freeze(); + } + + public Map.Immutable __putAllEquivalent(final java.util.Map map, + final Comparator cmp) { + final Map.Transient tmpTransient = this.asTransient(); + tmpTransient.__putAllEquivalent(map, cmp); + return tmpTransient.freeze(); + } + + public Map.Immutable __remove(final K key) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieMap_5Bits_Spec0To16(newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); + } + + return this; + } + + public Map.Immutable __removeEquivalent(final K key, final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieMap_5Bits_Spec0To16(newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); + } + + return this; + } + + public V put(final K key, final V val) { + throw new UnsupportedOperationException(); + } + + public void putAll(final java.util.Map m) { + throw new UnsupportedOperationException(); + } + + public void clear() { + throw new UnsupportedOperationException(); + } + + public V remove(final Object key) { + throw new UnsupportedOperationException(); + } + + public int size() { + return cachedSize; + } + + public boolean isEmpty() { + return cachedSize == 0; + } + + public Iterator keyIterator() { + return new MapKeyIterator<>(rootNode); + } + + public Iterator valueIterator() { + return new MapValueIterator<>(rootNode); + } + + public Iterator> entryIterator() { + return new MapEntryIterator<>(rootNode); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_Spec0To16.this.keyIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_Spec0To16.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Spec0To16.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Spec0To16.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_Spec0To16.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_Spec0To16.this.valueIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_Spec0To16.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Spec0To16.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Spec0To16.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TrieMap_5Bits_Spec0To16.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public java.util.Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieMap_5Bits_Spec0To16.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Spec0To16.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Spec0To16.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_Spec0To16.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) + return false; + + for (@SuppressWarnings("unchecked") + Iterator it = that.entrySet().iterator(); it.hasNext();) { + Map.Entry entry = it.next(); + + try { + @SuppressWarnings("unchecked") + final K key = (K) entry.getKey(); + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + @SuppressWarnings("unchecked") + final V val = (V) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public Map.Transient asTransient() { + return new TransientTrieMap_5Bits_Spec0To16(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractMapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieMap_5Bits_Spec0To16NodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. Payload X Node + */ + protected int[][] arityCombinationsHistogram() { + final Iterator> it = nodeIterator(); + final int[][] sumArityCombinations = new int[33][33]; + + while (it.hasNext()) { + final AbstractMapNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[33]; + + final int maxArity = 32; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[33]; + for (int cumsum = 0, i = 0; i < 33; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 33; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + abstract static class Optional { + private static final Optional EMPTY = new Optional() { + @Override + boolean isPresent() { + return false; + } + + @Override + Object get() { + return null; + } + }; + + @SuppressWarnings("unchecked") + static Optional empty() { + return EMPTY; + } + + static Optional of(T value) { + return new Value(value); + } + + abstract boolean isPresent(); + + abstract T get(); + + private static final class Value extends Optional { + private final T value; + + private Value(T value) { + this.value = value; + } + + @Override + boolean isPresent() { + return true; + } + + @Override + T get() { + return value; + } + } + } + + static final class MapResult { + private V replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(V replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static MapResult unchanged() { + return new MapResult<>(); + } + + private MapResult() {} + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public V getReplacedValue() { + return replacedValue; + } + } + + protected static interface INode { + } + + protected static abstract class AbstractMapNode implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final K key, final int keyHash, final int shift); + + abstract boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final K key, final int keyHash, final int shift); + + abstract Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract CompactMapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + abstract CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractMapNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractMapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) + throw new NoSuchElementException(); + return AbstractMapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract K getKey(final int index); + + abstract V getValue(final int index); + + abstract java.util.Map.Entry getKeyValueEntry(final int index); + + @Deprecated + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + int size() { + final Iterator it = new MapKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactMapNode extends AbstractMapNode { + + static final int hashCodeLength() { + return 32; + } + + static final int bitPartitionSize() { + return 5; + } + + static final int bitPartitionMask() { + return 0b11111; + } + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & bitPartitionMask(); + } + + static final int bitpos(final int mask) { + return (int) (1 << mask); + } + + abstract int nodeMap(); + + abstract int dataMap(); + + enum ContentType { + KEY, VAL, RARE_KEY, RARE_VAL, NODE, SLOT + } + + int logicalToPhysicalIndex(final ContentType type, final int index) { + final int physicalIndex; + + switch (type) { + case KEY: + physicalIndex = TUPLE_LENGTH * index; + break; + case VAL: + physicalIndex = TUPLE_LENGTH * index + 1; + break; + case RARE_KEY: + physicalIndex = + TUPLE_LENGTH * index + TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap()); + break; + case RARE_VAL: + physicalIndex = + TUPLE_LENGTH * index + TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap()) + 1; + break; + case NODE: + physicalIndex = slotArity() - 1 - index; + break; + case SLOT: + physicalIndex = index; + break; + default: + throw new IllegalStateException("Cases not exhausted?"); + } + + return physicalIndex; + } + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + @Override + abstract CompactMapNode getNode(final int index); + + abstract CompactMapNode copyAndSetValue(final AtomicReference mutator, + final int bitpos, final V val); + + abstract CompactMapNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final K key, final V val); + + abstract CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos); + + abstract CompactMapNode copyAndSetNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromInlineToNode( + final AtomicReference mutator, final int bitpos, final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromNodeToInline( + final AtomicReference mutator, final int bitpos, final CompactMapNode node); + + CompactMapNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + static final CompactMapNode mergeTwoKeyValPairs(final K key0, final V val0, + final int keyHash0, final K key1, final V val1, final int keyHash1, final int shift) { + assert !(key0.equals(key1)); + + if (shift >= hashCodeLength()) { + // throw new + // IllegalStateException("Hash collision not yet fixed."); + return new HashCollisionMapNode_5Bits_Spec0To16<>(keyHash0, (K[]) new Object[] {key0, key1}, + (V[]) new Object[] {val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int dataMap = (int) (bitpos(mask0) | bitpos(mask1)); + + if (mask0 < mask1) { + return nodeOf(null, (int) 0, dataMap, key0, val0, key1, val1); + } else { + return nodeOf(null, (int) 0, dataMap, key1, val1, key0, val0); + } + } else { + final CompactMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, + keyHash1, shift + bitPartitionSize()); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf(null, nodeMap, (int) 0, node); + } + } + + static final CompactMapNode emptyTrieNodeConstant() { + return EMPTY_NODE; + } + + static final CompactMapNode EMPTY_NODE; + + static { + + EMPTY_NODE = new Map0To0Node_5Bits_Spec0To16<>(null, (int) 0, (int) 0); + + }; + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object[] nodes) { + return new BitmapIndexedMapNode<>(mutator, nodeMap, dataMap, nodes); + } + + @SuppressWarnings("unchecked") + static final CompactMapNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap) { + return EMPTY_NODE; + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1) { + return new Map0To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map0To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map0To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map0To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map0To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map0To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map0To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + return new Map0To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + return new Map0To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + return new Map0To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11) { + return new Map0To11Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + return new Map0To12Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13) { + return new Map0To13Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14) { + return new Map0To14Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15) { + return new Map0To15Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15, + final CompactMapNode node16) { + return new Map0To16Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15, + final CompactMapNode node16, final CompactMapNode node17) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {node17, node16, node15, node14, node13, node12, node11, node10, node9, node8, + node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1) { + return new Map1To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1) { + return new Map1To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map1To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map1To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map1To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map1To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map1To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map1To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map1To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map1To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map1To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + return new Map1To11Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + return new Map1To12Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13) { + return new Map1To13Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14) { + return new Map1To14Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15) { + return new Map1To15Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15, final CompactMapNode node16) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, node16, node15, node14, node13, node12, node11, node10, node9, node8, + node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2) { + return new Map2To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1) { + return new Map2To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2) { + return new Map2To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map2To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map2To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map2To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map2To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map2To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map2To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map2To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map2To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + return new Map2To11Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + return new Map2To12Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13) { + return new Map2To13Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14) { + return new Map2To14Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13, node14); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, node15, node14, node13, node12, node11, node10, node9, + node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3) { + return new Map3To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1) { + return new Map3To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map3To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map3To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map3To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map3To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map3To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map3To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + return new Map3To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + return new Map3To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + return new Map3To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11) { + return new Map3To11Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + return new Map3To12Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13) { + return new Map3To13Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, node14, node13, node12, node11, node10, + node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4) { + return new Map4To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1) { + return new Map4To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map4To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map4To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map4To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map4To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map4To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map4To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map4To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map4To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map4To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + return new Map4To11Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + return new Map4To12Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11, node12); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, node13, node12, node11, node10, + node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5) { + return new Map5To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1) { + return new Map5To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2) { + return new Map5To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map5To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map5To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map5To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map5To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map5To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map5To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map5To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map5To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + return new Map5To11Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, node12, node11, + node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6) { + return new Map6To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1) { + return new Map6To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map6To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map6To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map6To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map6To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map6To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map6To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + return new Map6To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + return new Map6To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + return new Map6To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + node11, node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7) { + return new Map7To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1) { + return new Map7To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map7To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map7To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map7To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map7To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map7To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map7To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map7To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map7To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8) { + return new Map8To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1) { + return new Map8To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2) { + return new Map8To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map8To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map8To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map8To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map8To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map8To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map8To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, node9, node8, node7, node6, node5, node4, node3, node2, + node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9) { + return new Map9To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1) { + return new Map9To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map9To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map9To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map9To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map9To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map9To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map9To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, node8, node7, node6, node5, node4, node3, node2, + node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10) { + return new Map10To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1) { + return new Map10To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map10To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map10To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map10To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map10To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map10To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, node7, node6, node5, node4, node3, + node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11) { + return new Map11To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final CompactMapNode node1) { + return new Map11To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final CompactMapNode node1, final CompactMapNode node2) { + return new Map11To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map11To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map11To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map11To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, node6, node5, node4, + node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12) { + return new Map12To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final CompactMapNode node1) { + return new Map12To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map12To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map12To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map12To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, node5, + node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13) { + return new Map13To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, + final CompactMapNode node1) { + return new Map13To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map13To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map13To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14) { + return new Map14To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final CompactMapNode node1) { + return new Map14To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final CompactMapNode node1, final CompactMapNode node2) { + return new Map14To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15) { + return new Map15To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final CompactMapNode node1) { + return new Map15To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final CompactMapNode node1, + final CompactMapNode node2) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final K key16, final V val16) { + return new Map16To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final K key16, final V val16, + final CompactMapNode node1) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final K key16, final V val16, final K key17, + final V val17) { + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, key17, val17}); + } + + static final CompactMapNode nodeOf0x0(final AtomicReference mutator, + final int nodeMap, final int dataMap) { + return EMPTY_NODE; + } + + static final CompactMapNode nodeOf1x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1) { + return new Map0To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1); + } + + static final CompactMapNode nodeOf2x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map0To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2); + } + + static final CompactMapNode nodeOf3x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map0To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map0To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4); + } + + static final CompactMapNode nodeOf5x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map0To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5); + } + + static final CompactMapNode nodeOf6x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map0To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6); + } + + static final CompactMapNode nodeOf7x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map0To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + return new Map0To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + return new Map0To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf10x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + return new Map0To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf11x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11) { + return new Map0To11Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf12x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + return new Map0To12Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + } + + static final CompactMapNode nodeOf13x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13) { + return new Map0To13Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + } + + static final CompactMapNode nodeOf14x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14) { + return new Map0To14Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + } + + static final CompactMapNode nodeOf15x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15) { + return new Map0To15Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + } + + static final CompactMapNode nodeOf16x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15, + final CompactMapNode node16) { + return new Map0To16Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + } + + static final CompactMapNode nodeOf17x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15, + final CompactMapNode node16, final CompactMapNode node17) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {node17, node16, node15, node14, node13, node12, node11, node10, node9, node8, + node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf18x0(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15, + final CompactMapNode node16, final CompactMapNode node17, + final CompactMapNode node18) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {node18, node17, node16, node15, node14, node13, node12, node11, node10, node9, + node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1) { + return new Map1To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1); + } + + static final CompactMapNode nodeOf1x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1) { + return new Map1To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1); + } + + static final CompactMapNode nodeOf2x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map1To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2); + } + + static final CompactMapNode nodeOf3x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map1To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3); + } + + static final CompactMapNode nodeOf4x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map1To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4); + } + + static final CompactMapNode nodeOf5x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map1To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5); + } + + static final CompactMapNode nodeOf6x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map1To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map1To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map1To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map1To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf10x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map1To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf11x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + return new Map1To11Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf12x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + return new Map1To12Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + } + + static final CompactMapNode nodeOf13x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13) { + return new Map1To13Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + } + + static final CompactMapNode nodeOf14x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14) { + return new Map1To14Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + } + + static final CompactMapNode nodeOf15x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15) { + return new Map1To15Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + } + + static final CompactMapNode nodeOf16x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15, final CompactMapNode node16) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, node16, node15, node14, node13, node12, node11, node10, node9, node8, + node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf17x1(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15, final CompactMapNode node16, + final CompactMapNode node17) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, node17, node16, node15, node14, node13, node12, node11, node10, node9, + node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2) { + return new Map2To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2); + } + + static final CompactMapNode nodeOf1x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1) { + return new Map2To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1); + } + + static final CompactMapNode nodeOf2x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2) { + return new Map2To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2); + } + + static final CompactMapNode nodeOf3x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map2To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3); + } + + static final CompactMapNode nodeOf4x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map2To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map2To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map2To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map2To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map2To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map2To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf10x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map2To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf11x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + return new Map2To11Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf12x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + return new Map2To12Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + } + + static final CompactMapNode nodeOf13x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13) { + return new Map2To13Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + } + + static final CompactMapNode nodeOf14x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14) { + return new Map2To14Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13, node14); + } + + static final CompactMapNode nodeOf15x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, node15, node14, node13, node12, node11, node10, node9, + node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf16x2(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15, final CompactMapNode node16) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, node16, node15, node14, node13, node12, node11, node10, + node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3) { + return new Map3To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3); + } + + static final CompactMapNode nodeOf1x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1) { + return new Map3To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1); + } + + static final CompactMapNode nodeOf2x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map3To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2); + } + + static final CompactMapNode nodeOf3x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map3To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map3To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map3To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map3To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map3To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + return new Map3To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + return new Map3To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf10x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + return new Map3To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf11x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11) { + return new Map3To11Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + static final CompactMapNode nodeOf12x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + return new Map3To12Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + } + + static final CompactMapNode nodeOf13x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13) { + return new Map3To13Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + } + + static final CompactMapNode nodeOf14x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, node14, node13, node12, node11, node10, + node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf15x3(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, node15, node14, node13, node12, node11, + node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4) { + return new Map4To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4); + } + + static final CompactMapNode nodeOf1x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1) { + return new Map4To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1); + } + + static final CompactMapNode nodeOf2x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map4To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2); + } + + static final CompactMapNode nodeOf3x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map4To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map4To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map4To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map4To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map4To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map4To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map4To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf10x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map4To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + static final CompactMapNode nodeOf11x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + return new Map4To11Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + } + + static final CompactMapNode nodeOf12x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + return new Map4To12Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11, node12); + } + + static final CompactMapNode nodeOf13x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, node13, node12, node11, node10, + node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf14x4(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, node14, node13, node12, node11, + node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5) { + return new Map5To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5); + } + + static final CompactMapNode nodeOf1x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1) { + return new Map5To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1); + } + + static final CompactMapNode nodeOf2x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2) { + return new Map5To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2); + } + + static final CompactMapNode nodeOf3x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map5To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map5To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map5To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map5To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map5To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map5To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8); + } + + static final CompactMapNode nodeOf9x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map5To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + } + + static final CompactMapNode nodeOf10x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map5To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + } + + static final CompactMapNode nodeOf11x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + return new Map5To11Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf12x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, node12, node11, + node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf13x5(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, node13, node12, + node11, node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x6(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6) { + return new Map6To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6); + } + + static final CompactMapNode nodeOf1x6(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1) { + return new Map6To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1); + } + + static final CompactMapNode nodeOf2x6(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map6To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2); + } + + static final CompactMapNode nodeOf3x6(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map6To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x6(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map6To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x6(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map6To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x6(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map6To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x6(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map6To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7); + } + + static final CompactMapNode nodeOf8x6(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + return new Map6To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8); + } + + static final CompactMapNode nodeOf9x6(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + return new Map6To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + } + + static final CompactMapNode nodeOf10x6(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + return new Map6To10Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf11x6(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + node11, node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf12x6(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + node12, node11, node10, node9, node8, node7, node6, node5, node4, node3, node2, + node1}); + } + + static final CompactMapNode nodeOf0x7(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7) { + return new Map7To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7); + } + + static final CompactMapNode nodeOf1x7(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1) { + return new Map7To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1); + } + + static final CompactMapNode nodeOf2x7(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map7To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + } + + static final CompactMapNode nodeOf3x7(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map7To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x7(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map7To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x7(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map7To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + } + + static final CompactMapNode nodeOf6x7(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map7To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + } + + static final CompactMapNode nodeOf7x7(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map7To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + } + + static final CompactMapNode nodeOf8x7(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map7To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x7(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map7To9Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf10x7(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf11x7(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, node11, node10, node9, node8, node7, node6, node5, node4, node3, node2, + node1}); + } + + static final CompactMapNode nodeOf0x8(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8) { + return new Map8To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + } + + static final CompactMapNode nodeOf1x8(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1) { + return new Map8To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + } + + static final CompactMapNode nodeOf2x8(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2) { + return new Map8To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + } + + static final CompactMapNode nodeOf3x8(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map8To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + } + + static final CompactMapNode nodeOf4x8(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map8To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + } + + static final CompactMapNode nodeOf5x8(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map8To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + } + + static final CompactMapNode nodeOf6x8(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map8To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x8(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map8To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x8(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map8To8Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x8(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, node9, node8, node7, node6, node5, node4, node3, node2, + node1}); + } + + static final CompactMapNode nodeOf10x8(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, node10, node9, node8, node7, node6, node5, node4, node3, node2, + node1}); + } + + static final CompactMapNode nodeOf0x9(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9) { + return new Map9To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + } + + static final CompactMapNode nodeOf1x9(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1) { + return new Map9To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + } + + static final CompactMapNode nodeOf2x9(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map9To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2); + } + + static final CompactMapNode nodeOf3x9(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map9To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + } + + static final CompactMapNode nodeOf4x9(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map9To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + } + + static final CompactMapNode nodeOf5x9(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map9To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x9(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map9To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x9(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map9To7Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x9(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, node8, node7, node6, node5, node4, node3, node2, + node1}); + } + + static final CompactMapNode nodeOf9x9(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, node9, node8, node7, node6, node5, node4, node3, + node2, node1}); + } + + static final CompactMapNode nodeOf0x10(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10) { + return new Map10To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10); + } + + static final CompactMapNode nodeOf1x10(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1) { + return new Map10To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + } + + static final CompactMapNode nodeOf2x10(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map10To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + } + + static final CompactMapNode nodeOf3x10(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map10To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x10(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map10To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x10(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map10To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x10(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map10To6Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x10(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, node7, node6, node5, node4, node3, + node2, node1}); + } + + static final CompactMapNode nodeOf8x10(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, node8, node7, node6, node5, node4, + node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x11(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11) { + return new Map11To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + } + + static final CompactMapNode nodeOf1x11(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final CompactMapNode node1) { + return new Map11To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + } + + static final CompactMapNode nodeOf2x11(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final CompactMapNode node1, final CompactMapNode node2) { + return new Map11To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + } + + static final CompactMapNode nodeOf3x11(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map11To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x11(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map11To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x11(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map11To5Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x11(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, node6, node5, node4, + node3, node2, node1}); + } + + static final CompactMapNode nodeOf7x11(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, node7, node6, node5, + node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x12(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12) { + return new Map12To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + } + + static final CompactMapNode nodeOf1x12(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final CompactMapNode node1) { + return new Map12To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + } + + static final CompactMapNode nodeOf2x12(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map12To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + } + + static final CompactMapNode nodeOf3x12(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map12To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x12(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map12To4Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x12(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, node5, + node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf6x12(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, node6, + node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x13(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13) { + return new Map13To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + } + + static final CompactMapNode nodeOf1x13(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, + final CompactMapNode node1) { + return new Map13To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + } + + static final CompactMapNode nodeOf2x13(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map13To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + } + + static final CompactMapNode nodeOf3x13(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map13To3Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x13(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf5x13(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x14(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14) { + return new Map14To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + } + + static final CompactMapNode nodeOf1x14(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final CompactMapNode node1) { + return new Map14To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + } + + static final CompactMapNode nodeOf2x14(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final CompactMapNode node1, final CompactMapNode node2) { + return new Map14To2Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + } + + static final CompactMapNode nodeOf3x14(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, node3, node2, node1}); + } + + static final CompactMapNode nodeOf4x14(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x15(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15) { + return new Map15To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + } + + static final CompactMapNode nodeOf1x15(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final CompactMapNode node1) { + return new Map15To1Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + } + + static final CompactMapNode nodeOf2x15(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final CompactMapNode node1, + final CompactMapNode node2) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, node2, node1}); + } + + static final CompactMapNode nodeOf3x15(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x16(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final K key16, final V val16) { + return new Map16To0Node_5Bits_Spec0To16<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + } + + static final CompactMapNode nodeOf1x16(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final K key16, final V val16, + final CompactMapNode node1) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, node1}); + } + + static final CompactMapNode nodeOf2x16(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final K key16, final V val16, + final CompactMapNode node1, final CompactMapNode node2) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, node2, node1}); + } + + static final CompactMapNode nodeOf0x17(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final K key16, final V val16, final K key17, + final V val17) { + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, key17, val17}); + } + + static final CompactMapNode nodeOf1x17(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final K key16, final V val16, final K key17, + final V val17, final CompactMapNode node1) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, key17, val17, node1}); + } + + static final CompactMapNode nodeOf0x18(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9, final K key10, final V val10, final K key11, + final V val11, final K key12, final V val12, final K key13, final V val13, final K key14, + final V val14, final K key15, final V val15, final K key16, final V val16, final K key17, + final V val17, final K key18, final V val18) { + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, key17, val17, key18, val18}); + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + CompactMapNode nodeAt(final int bitpos) { + return getNode(nodeIndex(bitpos)); + } + + boolean containsKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index).equals(key); + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + bitPartitionSize()); + } + + return false; + } + + boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return cmp.compare(getKey(index), key) == 0; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + bitPartitionSize(), cmp); + } + + return false; + } + + Optional findByKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index).equals(key)) { + final V result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + bitPartitionSize()); + } + + return Optional.empty(); + } + + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (cmp.compare(getKey(index), key) == 0) { + final V result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + bitPartitionSize(), cmp); + } + + return Optional.empty(); + } + + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (currentKey.equals(key)) { + final V currentVal = getValue(dataIndex); + + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } else { + final V currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + bitPartitionSize(), details); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (cmp.compare(currentKey, key) == 0) { + final V currentVal = getValue(dataIndex); + + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } else { + final V currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + bitPartitionSize(), details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex).equals(key)) { + final V currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(1), + getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(0), + getValue(0)); + } + } else if (this.arity() == 17) { + return removeInplaceValueAndConvertToSpecializedNode(mutator, bitpos); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + bitPartitionSize(), details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + details.modified(); + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (cmp.compare(getKey(dataIndex), key) == 0) { + final V currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(1), + getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(0), + getValue(0)); + } + } else if (this.arity() == 17) { + return removeInplaceValueAndConvertToSpecializedNode(mutator, bitpos); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + bitPartitionSize(), details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + details.modified(); + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = (int) (map >> 1); + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getKey(i)), + Objects.hashCode(getValue(i)))); + + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedMapNode extends CompactMapNode { + + private final int nodeMap; + private final int dataMap; + + CompactMixedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + protected static abstract class CompactNodesOnlyMapNode extends CompactMapNode { + + private final int nodeMap; + + CompactNodesOnlyMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return 0; + } + + } + + protected static abstract class CompactValuesOnlyMapNode extends CompactMapNode { + + private final int dataMap; + + CompactValuesOnlyMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return 0; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + protected static abstract class CompactEmptyMapNode extends CompactMapNode { + + CompactEmptyMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) {} + + @Override + public int nodeMap() { + return 0; + } + + @Override + public int dataMap() { + return 0; + } + + } + + static final class FeatureFlags { + public static final long SUPPORTS_NOTHING = 0; + public static final long SUPPORTS_NODES = 1 << 0; + public static final long SUPPORTS_PAYLOAD = 1 << 1; + } + + private static final class BitmapIndexedMapNode extends CompactMixedMapNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + super(mutator, nodeMap, dataMap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + + assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < TUPLE_LENGTH * payloadArity(); i++) { + assert ((nodes[i] instanceof CompactMapNode) == false); + } + for (int i = TUPLE_LENGTH * payloadArity(); i < nodes.length; i++) { + assert ((nodes[i] instanceof CompactMapNode) == true); + } + } + + assert arity() > 16; + assert nodeInvariant(); + } + + @SuppressWarnings("unchecked") + @Override + K getKey(final int index) { + return (K) nodes[TUPLE_LENGTH * index]; + } + + @SuppressWarnings("unchecked") + @Override + V getValue(final int index) { + return (V) nodes[TUPLE_LENGTH * index + 1]; + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + return entryOf((K) nodes[TUPLE_LENGTH * index], (V) nodes[TUPLE_LENGTH * index + 1]); + } + + @SuppressWarnings("unchecked") + @Override + CompactMapNode getNode(final int index) { + return (CompactMapNode) nodes[nodes.length - 1 - index]; + } + + @SuppressWarnings("unchecked") + @Override + Iterator> nodeIterator() { + final int length = nodeArity(); + final int offset = nodes.length - length; + + if (DEBUG) { + for (int i = offset; i < offset + length; i++) { + assert ((nodes[i] instanceof AbstractMapNode) == true); + } + } + + return (Iterator) ArrayIterator.of(nodes, offset, length); + } + + @Override + boolean hasPayload() { + return dataMap() != 0; + } + + @Override + int payloadArity() { + return java.lang.Integer.bitCount(dataMap()); + } + + @Override + boolean hasNodes() { + return nodeMap() != 0; + } + + @Override + int nodeArity() { + return java.lang.Integer.bitCount(nodeMap()); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos) + 1; + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = val; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(bitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = val; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + return nodeOf(mutator, nodeMap(), (int) (dataMap() | bitpos), dst); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + return nodeOf(mutator, nodeMap(), (int) (dataMap() ^ bitpos), dst); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2 + 1]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 2, dst, idxNew + 1, src.length - idxNew - 2); + + return nodeOf(mutator, (int) (nodeMap() | bitpos), (int) (dataMap() ^ bitpos), dst); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 2]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = node.getKey(0); + dst[idxNew + 1] = node.getValue(0); + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 2, src.length - idxOld - 1); + + return nodeOf(mutator, (int) (nodeMap() ^ bitpos), (int) (dataMap() | bitpos), dst); + } + + @Override + CompactMapNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (payloadArity()) { // 0 <= payloadArity <= 17 // or ts.nMax + case 1: { + + switch (valIndex) { + case 0: { + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + final CompactMapNode node11 = getNode(10); + final CompactMapNode node12 = getNode(11); + final CompactMapNode node13 = getNode(12); + final CompactMapNode node14 = getNode(13); + final CompactMapNode node15 = getNode(14); + final CompactMapNode node16 = getNode(15); + + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + + } + case 2: { + K key1; + V val1; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + final CompactMapNode node11 = getNode(10); + final CompactMapNode node12 = getNode(11); + final CompactMapNode node13 = getNode(12); + final CompactMapNode node14 = getNode(13); + final CompactMapNode node15 = getNode(14); + + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + + } + case 3: { + K key1; + V val1; + K key2; + V val2; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + final CompactMapNode node11 = getNode(10); + final CompactMapNode node12 = getNode(11); + final CompactMapNode node13 = getNode(12); + final CompactMapNode node14 = getNode(13); + + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + + } + case 4: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + final CompactMapNode node11 = getNode(10); + final CompactMapNode node12 = getNode(11); + final CompactMapNode node13 = getNode(12); + + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + + } + case 5: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + final CompactMapNode node11 = getNode(10); + final CompactMapNode node12 = getNode(11); + + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + + } + case 6: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + final CompactMapNode node11 = getNode(10); + + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + + } + case 7: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + + } + case 8: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + K key7; + V val7; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + + } + case 9: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + K key7; + V val7; + K key8; + V val8; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7, node8); + + } + case 10: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + K key7; + V val7; + K key8; + V val8; + K key9; + V val9; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + + } + case 11: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + K key7; + V val7; + K key8; + V val8; + K key9; + V val9; + K key10; + V val10; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + + } + case 12: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + K key7; + V val7; + K key8; + V val8; + K key9; + V val9; + K key10; + V val10; + K key11; + V val11; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 11: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + + } + case 13: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + K key7; + V val7; + K key8; + V val8; + K key9; + V val9; + K key10; + V val10; + K key11; + V val11; + K key12; + V val12; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 11: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 12: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + + } + case 14: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + K key7; + V val7; + K key8; + V val8; + K key9; + V val9; + K key10; + V val10; + K key11; + V val11; + K key12; + V val12; + K key13; + V val13; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 11: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 12: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 13: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + + } + case 15: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + K key7; + V val7; + K key8; + V val8; + K key9; + V val9; + K key10; + V val10; + K key11; + V val11; + K key12; + V val12; + K key13; + V val13; + K key14; + V val14; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 11: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 12: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 13: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 14: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(13); + val14 = getValue(13); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + + } + case 16: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + K key7; + V val7; + K key8; + V val8; + K key9; + V val9; + K key10; + V val10; + K key11; + V val11; + K key12; + V val12; + K key13; + V val13; + K key14; + V val14; + K key15; + V val15; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 11: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 12: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 13: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 14: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(13); + val14 = getValue(13); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 15: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(13); + val14 = getValue(13); + key15 = getKey(14); + val15 = getValue(14); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + + } + case 17: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + K key7; + V val7; + K key8; + V val8; + K key9; + V val9; + K key10; + V val10; + K key11; + V val11; + K key12; + V val12; + K key13; + V val13; + K key14; + V val14; + K key15; + V val15; + K key16; + V val16; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 11: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 12: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 13: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 14: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(13); + val14 = getValue(13); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 15: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(13); + val14 = getValue(13); + key15 = getKey(14); + val15 = getValue(14); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 16: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(13); + val14 = getValue(13); + key15 = getKey(14); + val15 = getValue(14); + key16 = getKey(15); + val16 = getValue(15); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + + } + default: + throw new IllegalStateException("Index out of range."); + } + } + } + + private static final class HashCollisionMapNode_5Bits_Spec0To16 + extends CompactMapNode { + private final K[] keys; + private final V[] vals; + private final int hash; + + HashCollisionMapNode_5Bits_Spec0To16(final int hash, final K[] keys, final V[] vals) { + this.keys = keys; + this.vals = vals; + this.hash = hash; + + assert payloadArity() >= 2; + } + + boolean containsKey(final K key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (K k : keys) { + if (k.equals(key)) { + return true; + } + } + } + return false; + } + + boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (K k : keys) { + if (cmp.compare(k, key) == 0) { + return true; + } + } + } + return false; + } + + Optional findByKey(final K key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (key.equals(_key)) { + final V val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (cmp.compare(key, _key) == 0) { + final V val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final V currentVal = vals[idx]; + + if (currentVal.equals(val)) { + return this; + } else { + // add new mapping + final V[] src = this.vals; + @SuppressWarnings("unchecked") + final V[] dst = (V[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode_5Bits_Spec0To16<>(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + @SuppressWarnings("unchecked") + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + @SuppressWarnings("unchecked") + final V[] valsNew = (V[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits_Spec0To16<>(keyHash, keysNew, valsNew); + } + + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final V currentVal = vals[idx]; + + if (cmp.compare(currentVal, val) == 0) { + return this; + } else { + // add new mapping + final V[] src = this.vals; + @SuppressWarnings("unchecked") + final V[] dst = (V[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode_5Bits_Spec0To16<>(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + @SuppressWarnings("unchecked") + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + @SuppressWarnings("unchecked") + final V[] valsNew = (V[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits_Spec0To16<>(keyHash, keysNew, valsNew); + } + + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final V currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final V theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details); + } else { + @SuppressWarnings("unchecked") + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + @SuppressWarnings("unchecked") + final V[] valsNew = (V[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits_Spec0To16<>(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final V currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final V theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details, cmp); + } else { + @SuppressWarnings("unchecked") + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + @SuppressWarnings("unchecked") + final V[] valsNew = (V[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits_Spec0To16<>(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return keys.length; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + int arity() { + return payloadArity(); + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + K getKey(final int index) { + return keys[index]; + } + + @Override + V getValue(final int index) { + return vals[index]; + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + return entryOf(keys[index], vals[index]); + } + + @Override + public CompactMapNode getNode(int index) { + throw new IllegalStateException("Is leaf node."); + } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + int nodeMap() { + throw new UnsupportedOperationException(); + } + + @Override + int dataMap() { + throw new UnsupportedOperationException(); + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractMapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractMapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + @SuppressWarnings("unchecked") + AbstractMapNode[] nodes = new AbstractMapNode[MAX_DEPTH]; + + AbstractMapIterator(AbstractMapNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractMapNode nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class MapKeyIterator extends AbstractMapIterator + implements Iterator { + + MapKeyIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + protected static class MapValueIterator extends AbstractMapIterator + implements Iterator { + + MapValueIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public V next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getValue(currentValueCursor++); + } + } + + } + + protected static class MapEntryIterator extends AbstractMapIterator + implements Iterator> { + + MapEntryIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public java.util.Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKeyValueEntry(currentValueCursor++); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieMap_5Bits_Spec0To16NodeIterator + implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieMap_5Bits_Spec0To16NodeIterator(AbstractMapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractMapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieMap_5Bits_Spec0To16 implements Map.Transient { + final private AtomicReference mutator; + private AbstractMapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieMap_5Bits_Spec0To16(TrieMap_5Bits_Spec0To16 trieMap_5Bits_Spec0To16) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieMap_5Bits_Spec0To16.rootNode; + this.hashCode = trieMap_5Bits_Spec0To16.hashCode; + this.cachedSize = trieMap_5Bits_Spec0To16.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext();) { + final java.util.Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public V put(final K key, final V val) { + throw new UnsupportedOperationException(); + } + + public void putAll(final java.util.Map m) { + throw new UnsupportedOperationException(); + } + + public void clear() { + throw new UnsupportedOperationException(); + } + + public V remove(final Object key) { + throw new UnsupportedOperationException(); + } + + public boolean containsKey(final Object o) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + public V get(final Object o) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public V getEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final K key = (K) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public V __put(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final V old = details.getReplacedValue(); + + final int valHashOld = old.hashCode(); + final int valHashNew = val.hashCode(); + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } else { + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + public V __putEquivalent(final K key, final V val, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final V old = details.getReplacedValue(); + + final int valHashOld = old.hashCode(); + final int valHashNew = val.hashCode(); + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } else { + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + public boolean __putAll(final java.util.Map map) { + boolean modified = false; + + for (java.util.Map.Entry entry : map.entrySet()) { + final boolean isPresent = this.containsKey(entry.getKey()); + final V replaced = this.__put(entry.getKey(), entry.getValue()); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + public boolean __putAllEquivalent(final java.util.Map map, + final Comparator cmp) { + boolean modified = false; + + for (java.util.Map.Entry entry : map.entrySet()) { + final boolean isPresent = this.containsKeyEquivalent(entry.getKey(), cmp); + final V replaced = this.__putEquivalent(entry.getKey(), entry.getValue(), cmp); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + public V __remove(final K key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + public V __removeEquivalent(final K key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + public int size() { + return cachedSize; + } + + public boolean isEmpty() { + return cachedSize == 0; + } + + public Iterator keyIterator() { + return new TransientMapKeyIterator<>(this); + } + + public Iterator valueIterator() { + return new TransientMapValueIterator<>(this); + } + + public Iterator> entryIterator() { + return new TransientMapEntryIterator<>(this); + } + + public static class TransientMapKeyIterator extends MapKeyIterator { + final TransientTrieMap_5Bits_Spec0To16 collection; + K lastKey; + + public TransientMapKeyIterator(final TransientTrieMap_5Bits_Spec0To16 collection) { + super(collection.rootNode); + this.collection = collection; + } + + public K next() { + return lastKey = super.next(); + } + + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(lastKey); + } + } + + public static class TransientMapValueIterator extends MapValueIterator { + final TransientTrieMap_5Bits_Spec0To16 collection; + + public TransientMapValueIterator(final TransientTrieMap_5Bits_Spec0To16 collection) { + super(collection.rootNode); + this.collection = collection; + } + + public V next() { + return super.next(); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientMapEntryIterator extends MapEntryIterator { + final TransientTrieMap_5Bits_Spec0To16 collection; + + public TransientMapEntryIterator(final TransientTrieMap_5Bits_Spec0To16 collection) { + super(collection.rootNode); + this.collection = collection; + } + + public java.util.Map.Entry next() { + return super.next(); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits_Spec0To16.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Spec0To16.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Spec0To16.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Spec0To16.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits_Spec0To16.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits_Spec0To16.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Spec0To16.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Spec0To16.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Spec0To16.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieMap_5Bits_Spec0To16.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public java.util.Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Spec0To16.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Spec0To16.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Spec0To16.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits_Spec0To16.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) + return false; + + for (@SuppressWarnings("unchecked") + Iterator it = that.entrySet().iterator(); it.hasNext();) { + Map.Entry entry = it.next(); + + try { + @SuppressWarnings("unchecked") + final K key = (K) entry.getKey(); + final Optional result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + @SuppressWarnings("unchecked") + final V val = (V) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public Map.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieMap_5Bits_Spec0To16(rootNode, hashCode, cachedSize); + } + } + + private static final class Map0To0Node_5Bits_Spec0To16 extends CompactEmptyMapNode { + + private Map0To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + super(mutator, nodeMap, dataMap); + } + + boolean hasSlots() { + return false; + } + + int slotArity() { + return 0; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_EMPTY; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x1(mutator, nodeMap, dataMap, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map0To1Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + + private Map0To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 1; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x0(mutator, nodeMap, dataMap, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x1(mutator, nodeMap, dataMap, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To2Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map0To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 2; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x0(mutator, nodeMap, dataMap, node, node2); + case 1: + return nodeOf2x0(mutator, nodeMap, dataMap, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To3Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map0To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 3; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x0(mutator, nodeMap, dataMap, node, node2, node3); + case 1: + return nodeOf3x0(mutator, nodeMap, dataMap, node1, node, node3); + case 2: + return nodeOf3x0(mutator, nodeMap, dataMap, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To4Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map0To4Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 4; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x0(mutator, nodeMap, dataMap, node, node2, node3, node4); + case 1: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node, node3, node4); + case 2: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node2, node, node4); + case 3: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To5Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map0To5Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 5; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5); + case 1: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5); + case 2: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5); + case 3: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5); + case 4: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To6Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map0To6Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 6; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To7Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map0To7Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 7; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7); + case 2: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7); + case 3: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7); + case 4: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7); + case 5: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7); + case 6: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To8Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map0To8Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 8; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8); + case 3: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8); + case 4: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8); + case 5: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8); + case 6: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8); + case 7: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To9Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map0To9Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 9; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9); + case 4: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9); + case 5: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9); + case 6: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9); + case 7: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9); + case 8: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To10Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map0To10Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 10; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + case 1: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10); + case 2: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10); + case 3: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10); + case 4: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10); + case 5: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10); + case 6: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10); + case 7: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10); + case 8: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10); + case 9: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To11Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + + private Map0To11Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 11; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node11; + case 1: + return node10; + case 2: + return node9; + case 3: + return node8; + case 4: + return node7; + case 5: + return node6; + case 6: + return node5; + case 7: + return node4; + case 8: + return node3; + case 9: + return node2; + case 10: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 11; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf11x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11); + case 1: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10, node11); + case 2: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10, node11); + case 3: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10, node11); + case 4: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10, node11); + case 5: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10, node11); + case 6: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10, node11); + case 7: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10, node11); + case 8: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10, node11); + case 9: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node11); + case 10: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To12Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + + private Map0To12Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node12; + case 1: + return node11; + case 2: + return node10; + case 3: + return node9; + case 4: + return node8; + case 5: + return node7; + case 6: + return node6; + case 7: + return node5; + case 8: + return node4; + case 9: + return node3; + case 10: + return node2; + case 11: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 12; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf12x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10, node11, node12); + case 7: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10, node11, node12); + case 8: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10, node11, node12); + case 9: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node11, node12); + case 10: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node12); + case 11: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To13Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + + private Map0To13Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node13; + case 1: + return node12; + case 2: + return node11; + case 3: + return node10; + case 4: + return node9; + case 5: + return node8; + case 6: + return node7; + case 7: + return node6; + case 8: + return node5; + case 9: + return node4; + case 10: + return node3; + case 11: + return node2; + case 12: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 13; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf13x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13); + case 3: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10, node11, node12, node13); + case 4: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10, node11, node12, node13); + case 5: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10, node11, node12, node13); + case 6: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10, node11, node12, node13); + case 7: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10, node11, node12, node13); + case 8: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10, node11, node12, node13); + case 9: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node11, node12, node13); + case 10: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node12, node13); + case 11: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node13); + case 12: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To14Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + private final CompactMapNode node14; + + private Map0To14Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + this.node14 = node14; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node14; + case 1: + return node13; + case 2: + return node12; + case 3: + return node11; + case 4: + return node10; + case 5: + return node9; + case 6: + return node8; + case 7: + return node7; + case 8: + return node6; + case 9: + return node5; + case 10: + return node4; + case 11: + return node3; + case 12: + return node2; + case 13: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13, node14); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 14; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf14x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14); + case 2: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14); + case 3: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14); + case 4: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10, node11, node12, node13, node14); + case 5: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10, node11, node12, node13, node14); + case 6: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10, node11, node12, node13, node14); + case 7: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10, node11, node12, node13, node14); + case 8: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10, node11, node12, node13, node14); + case 9: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node11, node12, node13, node14); + case 10: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node12, node13, node14); + case 11: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node13, node14); + case 12: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node, node14); + case 13: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To15Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + private final CompactMapNode node14; + private final CompactMapNode node15; + + private Map0To15Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + this.node14 = node14; + this.node15 = node15; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node15; + case 1: + return node14; + case 2: + return node13; + case 3: + return node12; + case 4: + return node11; + case 5: + return node10; + case 6: + return node9; + case 7: + return node8; + case 8: + return node7; + case 9: + return node6; + case 10: + return node5; + case 11: + return node4; + case 12: + return node3; + case 13: + return node2; + case 14: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13, node14, node15); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 15; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf15x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 1: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 2: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 3: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 4: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 5: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 6: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10, node11, node12, node13, node14, node15); + case 7: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10, node11, node12, node13, node14, node15); + case 8: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10, node11, node12, node13, node14, node15); + case 9: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node11, node12, node13, node14, node15); + case 10: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node12, node13, node14, node15); + case 11: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node13, node14, node15); + case 12: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node, node14, node15); + case 13: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node, node15); + case 14: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 14: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To16Node_5Bits_Spec0To16 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + private final CompactMapNode node14; + private final CompactMapNode node15; + private final CompactMapNode node16; + + private Map0To16Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15, final CompactMapNode node16) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + this.node14 = node14; + this.node15 = node15; + this.node16 = node16; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + V getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node16; + case 1: + return node15; + case 2: + return node14; + case 3: + return node13; + case 4: + return node12; + case 5: + return node11; + case 6: + return node10; + case 7: + return node9; + case 8: + return node8; + case 9: + return node7; + case 10: + return node6; + case 11: + return node5; + case 12: + return node4; + case 13: + return node3; + case 14: + return node2; + case 15: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13, node14, node15, node16); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 16; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf16x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf16x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 1: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 2: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 3: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 4: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 5: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 6: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 7: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10, node11, node12, node13, node14, node15, node16); + case 8: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10, node11, node12, node13, node14, node15, node16); + case 9: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node11, node12, node13, node14, node15, node16); + case 10: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node12, node13, node14, node15, node16); + case 11: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node13, node14, node15, node16); + case 12: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node, node14, node15, node16); + case 13: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node, node15, node16); + case 14: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node, node16); + case 15: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 14: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 15: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + + private Map1To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 2; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x1(mutator, nodeMap, dataMap, key1, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x2(mutator, nodeMap, dataMap, key, val, key1, val1); + case 1: + return nodeOf0x2(mutator, nodeMap, dataMap, key1, val1, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x0(mutator, nodeMap, dataMap); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x0(mutator, nodeMap, dataMap, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map1To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + + private Map1To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 3; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key1, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1); + case 1: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x0(mutator, nodeMap, dataMap, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key1, val1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x0(mutator, nodeMap, dataMap, node, node1); + case 1: + return nodeOf2x0(mutator, nodeMap, dataMap, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x2(mutator, nodeMap, dataMap, key, val, key1, val1); + case 1: + return nodeOf0x2(mutator, nodeMap, dataMap, key1, val1, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map1To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 4; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key1, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x0(mutator, nodeMap, dataMap, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key1, val1, node, node2); + case 1: + return nodeOf2x1(mutator, nodeMap, dataMap, key1, val1, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x0(mutator, nodeMap, dataMap, node, node1, node2); + case 1: + return nodeOf3x0(mutator, nodeMap, dataMap, node1, node, node2); + case 2: + return nodeOf3x0(mutator, nodeMap, dataMap, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2); + case 1: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1); + case 1: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To3Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map1To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 5; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x0(mutator, nodeMap, dataMap, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3); + case 1: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3); + case 2: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x0(mutator, nodeMap, dataMap, node, node1, node2, node3); + case 1: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node, node2, node3); + case 2: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node2, node, node3); + case 3: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To4Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map1To4Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 6; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4); + case 1: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4); + case 2: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4); + case 3: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4); + case 1: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4); + case 2: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4); + case 3: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4); + case 4: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, + node4); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, + node4); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node4); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To5Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map1To5Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 7; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5); + case 1: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5); + case 2: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5); + case 3: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5); + case 4: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To6Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map1To6Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 8; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6); + case 1: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6); + case 2: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6); + case 3: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6); + case 4: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6); + case 5: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To7Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map1To7Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 9; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7); + case 2: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7); + case 3: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7); + case 4: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7); + case 5: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node, node7); + case 6: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7); + case 7: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6, node7); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6, node7); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6, node7); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6, node7); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6, node7); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node7); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To8Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map1To8Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 10; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8); + case 3: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8); + case 4: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8); + case 5: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node, node7, node8); + case 6: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node, node8); + case 7: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8); + case 7: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8); + case 8: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6, node7, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6, node7, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6, node7, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6, node7, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6, node7, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node7, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To9Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map1To9Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 11; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9); + case 4: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9); + case 5: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node, node7, node8, node9); + case 6: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node, node8, node9); + case 7: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7, node, node9); + case 8: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9); + case 4: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9); + case 5: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9); + case 6: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9); + case 7: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9); + case 8: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9); + case 9: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6, node7, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6, node7, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6, node7, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6, node7, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6, node7, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node7, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To10Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map1To10Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10); + case 1: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9, node10); + case 2: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9, node10); + case 3: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9, node10); + case 4: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9, node10); + case 5: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node7, node8, node9, node10); + case 6: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node8, node9, node10); + case 7: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node9, node10); + case 8: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node10); + case 9: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf11x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10); + case 1: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10); + case 2: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9, node10); + case 3: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9, node10); + case 4: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9, node10); + case 5: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9, node10); + case 6: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9, node10); + case 7: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9, node10); + case 8: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9, node10); + case 9: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node10); + case 10: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node7, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To11Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + + private Map1To11Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node11; + case 1: + return node10; + case 2: + return node9; + case 3: + return node8; + case 4: + return node7; + case 5: + return node6; + case 6: + return node5; + case 7: + return node4; + case 8: + return node3; + case 9: + return node2; + case 10: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 11; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node7, node8, node9, node10, node11); + case 6: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node8, node9, node10, node11); + case 7: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node9, node10, node11); + case 8: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node10, node11); + case 9: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node11); + case 10: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf12x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9, node10, node11); + case 6: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9, node10, node11); + case 7: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9, node10, node11); + case 8: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9, node10, node11); + case 9: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node10, node11); + case 10: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node11); + case 11: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To12Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + + private Map1To12Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node12; + case 1: + return node11; + case 2: + return node10; + case 3: + return node9; + case 4: + return node8; + case 5: + return node7; + case 6: + return node6; + case 7: + return node5; + case 8: + return node4; + case 9: + return node3; + case 10: + return node2; + case 11: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 12; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node8, node9, node10, node11, node12); + case 7: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node9, node10, node11, node12); + case 8: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node10, node11, node12); + case 9: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node11, node12); + case 10: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node12); + case 11: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf13x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9, node10, node11, node12); + case 7: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9, node10, node11, node12); + case 8: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9, node10, node11, node12); + case 9: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node10, node11, node12); + case 10: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node11, node12); + case 11: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node12); + case 12: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To13Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + + private Map1To13Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node13; + case 1: + return node12; + case 2: + return node11; + case 3: + return node10; + case 4: + return node9; + case 5: + return node8; + case 6: + return node7; + case 7: + return node6; + case 8: + return node5; + case 9: + return node4; + case 10: + return node3; + case 11: + return node2; + case 12: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 13; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 3: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 4: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9, node10, node11, node12, node13); + case 5: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node7, node8, node9, node10, node11, node12, node13); + case 6: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node8, node9, node10, node11, node12, node13); + case 7: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node9, node10, node11, node12, node13); + case 8: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node10, node11, node12, node13); + case 9: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node11, node12, node13); + case 10: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node12, node13); + case 11: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node13); + case 12: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf14x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 3: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 4: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 5: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9, node10, node11, node12, node13); + case 6: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9, node10, node11, node12, node13); + case 7: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9, node10, node11, node12, node13); + case 8: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9, node10, node11, node12, node13); + case 9: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node10, node11, node12, node13); + case 10: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node11, node12, node13); + case 11: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node12, node13); + case 12: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node, node13); + case 13: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To14Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + private final CompactMapNode node14; + + private Map1To14Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + this.node14 = node14; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node14; + case 1: + return node13; + case 2: + return node12; + case 3: + return node11; + case 4: + return node10; + case 5: + return node9; + case 6: + return node8; + case 7: + return node7; + case 8: + return node6; + case 9: + return node5; + case 10: + return node4; + case 11: + return node3; + case 12: + return node2; + case 13: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13, node14); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 14; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 2: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 3: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 4: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 5: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node7, node8, node9, node10, node11, node12, node13, node14); + case 6: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node8, node9, node10, node11, node12, node13, node14); + case 7: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node9, node10, node11, node12, node13, node14); + case 8: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node10, node11, node12, node13, node14); + case 9: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node11, node12, node13, node14); + case 10: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node12, node13, node14); + case 11: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node13, node14); + case 12: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node, node14); + case 13: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf15x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 2: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 3: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 4: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 5: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 6: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9, node10, node11, node12, node13, node14); + case 7: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9, node10, node11, node12, node13, node14); + case 8: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9, node10, node11, node12, node13, node14); + case 9: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node10, node11, node12, node13, node14); + case 10: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node11, node12, node13, node14); + case 11: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node12, node13, node14); + case 12: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node, node13, node14); + case 13: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node, node14); + case 14: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To15Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + private final CompactMapNode node14; + private final CompactMapNode node15; + + private Map1To15Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + this.node14 = node14; + this.node15 = node15; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node15; + case 1: + return node14; + case 2: + return node13; + case 3: + return node12; + case 4: + return node11; + case 5: + return node10; + case 6: + return node9; + case 7: + return node8; + case 8: + return node7; + case 9: + return node6; + case 10: + return node5; + case 11: + return node4; + case 12: + return node3; + case 13: + return node2; + case 14: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13, node14, node15); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 15; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf15x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf15x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 1: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 2: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 3: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 4: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 5: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 6: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node8, node9, node10, node11, node12, node13, node14, node15); + case 7: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node9, node10, node11, node12, node13, node14, node15); + case 8: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node10, node11, node12, node13, node14, node15); + case 9: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node11, node12, node13, node14, node15); + case 10: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node12, node13, node14, node15); + case 11: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node13, node14, node15); + case 12: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node, node14, node15); + case 13: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node, node15); + case 14: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf16x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 1: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 2: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 3: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 4: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 5: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 6: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 7: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9, node10, node11, node12, node13, node14, node15); + case 8: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9, node10, node11, node12, node13, node14, node15); + case 9: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node10, node11, node12, node13, node14, node15); + case 10: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node11, node12, node13, node14, node15); + case 11: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node12, node13, node14, node15); + case 12: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node, node13, node14, node15); + case 13: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node, node14, node15); + case 14: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node, node15); + case 15: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 14: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + + private Map2To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 4; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x2(mutator, nodeMap, dataMap, key1, val, key2, val2); + case 1: + return nodeOf0x2(mutator, nodeMap, dataMap, key1, val1, key2, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2); + case 1: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2); + case 2: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x1(mutator, nodeMap, dataMap, key2, val2); + case 1: + return nodeOf0x1(mutator, nodeMap, dataMap, key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key2, val2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key1, val1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map2To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + + private Map2To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 5; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1); + case 1: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1); + case 1: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1); + case 2: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key2, val2, node1); + case 1: + return nodeOf1x1(mutator, nodeMap, dataMap, key1, val1, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key2, val2, node, node1); + case 1: + return nodeOf2x1(mutator, nodeMap, dataMap, key2, val2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key1, val1, node, node1); + case 1: + return nodeOf2x1(mutator, nodeMap, dataMap, key1, val1, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2); + case 1: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2); + case 2: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map2To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 6; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2); + case 2: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key2, val2, node1, node2); + case 1: + return nodeOf2x1(mutator, nodeMap, dataMap, key1, val1, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2); + case 1: + return nodeOf3x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2); + case 2: + return nodeOf3x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2); + case 1: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2); + case 2: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2); + case 1: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2); + case 2: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1); + case 1: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1); + case 2: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To3Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map2To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 7; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3); + case 1: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3); + case 2: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3); + case 1: + return nodeOf4x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3); + case 2: + return nodeOf4x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3); + case 3: + return nodeOf4x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3); + case 1: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3); + case 2: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3); + case 3: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3); + case 2: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3); + case 2: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2); + case 2: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To4Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map2To4Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 8; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4); + case 1: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4); + case 2: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4); + case 3: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To5Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map2To5Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 9; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5); + case 1: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5); + case 2: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5); + case 3: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5); + case 4: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To6Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map2To6Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 10; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6); + case 2: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6); + case 3: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6); + case 4: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6); + case 5: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To7Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map2To7Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 11; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7); + case 2: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7); + case 3: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7); + case 4: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7); + case 5: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7); + case 6: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To8Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map2To8Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8); + case 3: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8); + case 4: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8); + case 5: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8); + case 6: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8); + case 7: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8); + case 3: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8); + case 4: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8); + case 5: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8); + case 6: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8); + case 7: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8); + case 8: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8); + case 3: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8); + case 4: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8); + case 5: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8); + case 6: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8); + case 7: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8); + case 8: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To9Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map2To9Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8, node9); + case 5: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8, node9); + case 6: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8, node9); + case 7: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node, node9); + case 8: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To10Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map2To10Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8, node9, node10); + case 5: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8, node9, node10); + case 6: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8, node9, node10); + case 7: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node, node9, node10); + case 8: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node, node10); + case 9: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To11Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + + private Map2To11Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node11; + case 1: + return node10; + case 2: + return node9; + case 3: + return node8; + case 4: + return node7; + case 5: + return node6; + case 6: + return node5; + case 7: + return node4; + case 8: + return node3; + case 9: + return node2; + case 10: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 11; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8, node9, node10, node11); + case 6: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8, node9, node10, node11); + case 7: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node, node9, node10, node11); + case 8: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node, node10, node11); + case 9: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node, node11); + case 10: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11); + case 6: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11); + case 7: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11); + case 8: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11); + case 9: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11); + case 10: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11); + case 11: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11); + case 6: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11); + case 7: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11); + case 8: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11); + case 9: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11); + case 10: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11); + case 11: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To12Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + + private Map2To12Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node12; + case 1: + return node11; + case 2: + return node10; + case 3: + return node9; + case 4: + return node8; + case 5: + return node7; + case 6: + return node6; + case 7: + return node5; + case 8: + return node4; + case 9: + return node3; + case 10: + return node2; + case 11: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 12; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8, node9, node10, node11, node12); + case 7: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node, node9, node10, node11, node12); + case 8: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node, node10, node11, node12); + case 9: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node, node11, node12); + case 10: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node, node12); + case 11: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11, node12); + case 7: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11, node12); + case 8: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11, node12); + case 9: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11, node12); + case 10: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11, node12); + case 11: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node12); + case 12: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11, node12); + case 7: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11, node12); + case 8: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11, node12); + case 9: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11, node12); + case 10: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11, node12); + case 11: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node12); + case 12: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To13Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + + private Map2To13Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node13; + case 1: + return node12; + case 2: + return node11; + case 3: + return node10; + case 4: + return node9; + case 5: + return node8; + case 6: + return node7; + case 7: + return node6; + case 8: + return node5; + case 9: + return node4; + case 10: + return node3; + case 11: + return node2; + case 12: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 13; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 3: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 4: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8, node9, node10, node11, node12, node13); + case 5: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8, node9, node10, node11, node12, node13); + case 6: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8, node9, node10, node11, node12, node13); + case 7: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node, node9, node10, node11, node12, node13); + case 8: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node, node10, node11, node12, node13); + case 9: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node, node11, node12, node13); + case 10: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node, node12, node13); + case 11: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node, node13); + case 12: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 3: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 4: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 5: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11, node12, node13); + case 6: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11, node12, node13); + case 7: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11, node12, node13); + case 8: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11, node12, node13); + case 9: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11, node12, node13); + case 10: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11, node12, node13); + case 11: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node12, node13); + case 12: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node, node13); + case 13: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 3: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 4: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 5: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11, node12, node13); + case 6: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11, node12, node13); + case 7: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11, node12, node13); + case 8: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11, node12, node13); + case 9: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11, node12, node13); + case 10: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11, node12, node13); + case 11: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node12, node13); + case 12: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node, node13); + case 13: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To14Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + private final CompactMapNode node14; + + private Map2To14Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + this.node14 = node14; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node14; + case 1: + return node13; + case 2: + return node12; + case 3: + return node11; + case 4: + return node10; + case 5: + return node9; + case 6: + return node8; + case 7: + return node7; + case 8: + return node6; + case 9: + return node5; + case 10: + return node4; + case 11: + return node3; + case 12: + return node2; + case 13: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13, node14); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 14; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf14x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13, node14); + case 1: + return nodeOf14x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13, node14); + case 2: + return nodeOf14x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 2: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 3: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 4: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 5: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8, node9, node10, node11, node12, node13, node14); + case 6: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8, node9, node10, node11, node12, node13, node14); + case 7: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node, node9, node10, node11, node12, node13, node14); + case 8: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node, node10, node11, node12, node13, node14); + case 9: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node, node11, node12, node13, node14); + case 10: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node, node12, node13, node14); + case 11: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node, node13, node14); + case 12: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node, node14); + case 13: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 2: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 3: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 4: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 5: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 6: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11, node12, node13, node14); + case 7: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11, node12, node13, node14); + case 8: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11, node12, node13, node14); + case 9: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11, node12, node13, node14); + case 10: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11, node12, node13, node14); + case 11: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node12, node13, node14); + case 12: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node, node13, node14); + case 13: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node, node14); + case 14: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 2: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 3: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 4: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 5: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 6: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11, node12, node13, node14); + case 7: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11, node12, node13, node14); + case 8: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11, node12, node13, node14); + case 9: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11, node12, node13, node14); + case 10: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11, node12, node13, node14); + case 11: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node12, node13, node14); + case 12: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node, node13, node14); + case 13: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node, node14); + case 14: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + + private Map3To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 6; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3); + case 1: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3); + case 2: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3); + case 1: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3); + case 2: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3); + case 3: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x2(mutator, nodeMap, dataMap, key2, val2, key3, val3); + case 1: + return nodeOf0x2(mutator, nodeMap, dataMap, key1, val1, key3, val3); + case 2: + return nodeOf0x2(mutator, nodeMap, dataMap, key1, val1, key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map3To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + + private Map3To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 7; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1); + case 1: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1); + case 2: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1); + case 1: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1); + case 2: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1); + case 3: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1); + case 1: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1); + case 2: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3); + case 1: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3); + case 2: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3); + case 3: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map3To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 8; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2); + case 2: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2); + case 2: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2); + case 3: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2); + case 2: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2); + case 2: + return nodeOf3x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2); + case 2: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2); + case 2: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2); + case 1: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2); + case 2: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2); + case 3: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1); + case 1: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1); + case 2: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1); + case 3: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To3Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map3To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 9; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3); + case 2: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3); + case 2: + return nodeOf4x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3); + case 3: + return nodeOf4x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3); + case 2: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3); + case 3: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3); + case 2: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3); + case 3: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3); + case 2: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3); + case 3: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3); + case 2: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3); + case 3: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2); + case 2: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2); + case 3: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To4Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map3To4Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 10; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4); + case 2: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4); + case 3: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To5Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map3To5Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 11; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5); + case 2: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5); + case 3: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5); + case 4: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To6Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map3To6Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6); + case 2: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6); + case 3: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6); + case 4: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6); + case 5: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To7Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map3To7Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7); + case 3: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7); + case 4: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7); + case 5: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7); + case 6: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To8Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map3To8Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7, node8); + case 4: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7, node8); + case 5: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7, node8); + case 6: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node8); + case 7: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To9Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map3To9Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7, node8, node9); + case 5: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7, node8, node9); + case 6: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node8, node9); + case 7: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node, node9); + case 8: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To10Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map3To10Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7, node8, node9, node10); + case 5: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7, node8, node9, node10); + case 6: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node8, node9, node10); + case 7: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node, node9, node10); + case 8: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node, node10); + case 9: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To11Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + + private Map3To11Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node11; + case 1: + return node10; + case 2: + return node9; + case 3: + return node8; + case 4: + return node7; + case 5: + return node6; + case 6: + return node5; + case 7: + return node4; + case 8: + return node3; + case 9: + return node2; + case 10: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 11; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7, node8, node9, node10, node11); + case 6: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node8, node9, node10, node11); + case 7: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node, node9, node10, node11); + case 8: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node, node10, node11); + case 9: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node, node11); + case 10: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11); + case 6: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11); + case 7: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11); + case 8: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11); + case 9: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11); + case 10: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11); + case 11: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11); + case 6: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11); + case 7: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11); + case 8: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11); + case 9: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11); + case 10: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11); + case 11: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11); + case 6: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11); + case 7: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11); + case 8: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11); + case 9: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11); + case 10: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11); + case 11: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To12Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + + private Map3To12Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node12; + case 1: + return node11; + case 2: + return node10; + case 3: + return node9; + case 4: + return node8; + case 5: + return node7; + case 6: + return node6; + case 7: + return node5; + case 8: + return node4; + case 9: + return node3; + case 10: + return node2; + case 11: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 12; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node8, node9, node10, node11, node12); + case 7: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node, node9, node10, node11, node12); + case 8: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node, node10, node11, node12); + case 9: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node, node11, node12); + case 10: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node, node12); + case 11: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11, node12); + case 7: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11, node12); + case 8: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11, node12); + case 9: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11, node12); + case 10: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11, node12); + case 11: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node12); + case 12: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11, node12); + case 7: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11, node12); + case 8: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11, node12); + case 9: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11, node12); + case 10: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11, node12); + case 11: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node12); + case 12: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11, node12); + case 7: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11, node12); + case 8: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11, node12); + case 9: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11, node12); + case 10: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11, node12); + case 11: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node12); + case 12: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To13Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + + private Map3To13Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node13; + case 1: + return node12; + case 2: + return node11; + case 3: + return node10; + case 4: + return node9; + case 5: + return node8; + case 6: + return node7; + case 7: + return node6; + case 8: + return node5; + case 9: + return node4; + case 10: + return node3; + case 11: + return node2; + case 12: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 13; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf13x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf13x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf13x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 3: + return nodeOf13x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 3: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 4: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7, node8, node9, node10, node11, node12, + node13); + case 5: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7, node8, node9, node10, node11, node12, + node13); + case 6: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node8, node9, node10, node11, node12, + node13); + case 7: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node, node9, node10, node11, node12, + node13); + case 8: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node, node10, node11, node12, + node13); + case 9: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node, node11, node12, node13); + case 10: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node, node12, node13); + case 11: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node13); + case 12: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 3: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 4: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 5: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11, node12, + node13); + case 6: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11, node12, + node13); + case 7: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11, node12, + node13); + case 8: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11, node12, + node13); + case 9: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11, node12, + node13); + case 10: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11, node12, + node13); + case 11: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node12, + node13); + case 12: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node, + node13); + case 13: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 3: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 4: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 5: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11, node12, + node13); + case 6: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11, node12, + node13); + case 7: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11, node12, + node13); + case 8: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11, node12, + node13); + case 9: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11, node12, + node13); + case 10: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11, node12, + node13); + case 11: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node12, + node13); + case 12: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node, + node13); + case 13: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 3: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 4: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 5: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11, node12, + node13); + case 6: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11, node12, + node13); + case 7: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11, node12, + node13); + case 8: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11, node12, + node13); + case 9: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11, node12, + node13); + case 10: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11, node12, + node13); + case 11: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node12, + node13); + case 12: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node, + node13); + case 13: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + + private Map4To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 8; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4); + case 1: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4); + case 2: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4); + case 3: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4); + case 1: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4); + case 2: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4); + case 3: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4); + case 4: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4); + case 1: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4); + case 2: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4); + case 3: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map4To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + + private Map4To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 9; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1); + case 1: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1); + case 2: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1); + case 3: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1); + case 1: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1); + case 2: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1); + case 3: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1); + case 4: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1); + case 1: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1); + case 2: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1); + case 3: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4); + case 1: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4); + case 2: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4); + case 3: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4); + case 4: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map4To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 10; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2); + case 2: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2); + case 3: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2); + case 2: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2); + case 3: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2); + case 4: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2); + case 2: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2); + case 3: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2); + case 1: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2); + case 2: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2); + case 3: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2); + case 4: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1); + case 1: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1); + case 2: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1); + case 3: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1); + case 4: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To3Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map4To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 11; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3); + case 3: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3); + case 3: + return nodeOf4x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3); + case 3: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3); + case 3: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3); + case 3: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3); + case 2: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3); + case 3: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3); + case 4: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3); + case 2: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3); + case 3: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3); + case 4: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2); + case 2: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2); + case 3: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2); + case 4: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To4Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map4To4Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4); + case 3: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3, node4); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3, node4); + case 3: + return nodeOf5x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node, node4); + case 4: + return nodeOf5x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3, node4); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3, node4); + case 3: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node, node4); + case 4: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3, node4); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3, node4); + case 3: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node, node4); + case 4: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3, node4); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3, node4); + case 3: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node4); + case 4: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To5Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map4To5Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4, node5); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4, node5); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5); + case 3: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5); + case 3: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5); + case 4: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5); + case 5: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5); + case 3: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5); + case 4: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5); + case 5: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3, node4, node5); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3, node4, node5); + case 3: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node, node4, node5); + case 4: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node, node5); + case 5: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3, node4, node5); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3, node4, node5); + case 3: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node4, node5); + case 4: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node5); + case 5: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To6Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map4To6Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6); + case 3: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To7Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map4To7Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6, node7); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6, node7); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6, node7); + case 5: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node7); + case 6: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6, node7); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6, node7); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6, node7); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6, node7); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node7); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To8Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map4To8Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6, node7, node8); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6, node7, node8); + case 5: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node7, node8); + case 6: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node8); + case 7: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6, node7, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6, node7, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6, node7, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node7, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To9Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map4To9Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6, node7, node8, node9); + case 5: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node7, node8, node9); + case 6: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node8, node9); + case 7: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node9); + case 8: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To10Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map4To10Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6, node7, node8, node9, node10); + case 5: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node7, node8, node9, node10); + case 6: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node8, node9, node10); + case 7: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node9, node10); + case 8: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node, node10); + case 9: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To11Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + + private Map4To11Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node11; + case 1: + return node10; + case 2: + return node9; + case 3: + return node8; + case 4: + return node7; + case 5: + return node6; + case 6: + return node5; + case 7: + return node4; + case 8: + return node3; + case 9: + return node2; + case 10: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 11; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node7, node8, node9, node10, node11); + case 6: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node8, node9, node10, node11); + case 7: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node9, node10, node11); + case 8: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node, node10, node11); + case 9: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node11); + case 10: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To12Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + + private Map4To12Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node12; + case 1: + return node11; + case 2: + return node10; + case 3: + return node9; + case 4: + return node8; + case 5: + return node7; + case 6: + return node6; + case 7: + return node5; + case 8: + return node4; + case 9: + return node3; + case 10: + return node2; + case 11: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 12; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf12x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf12x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf12x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf12x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf12x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6, node7, node8, node9, node10, node11, + node12); + case 4: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6, node7, node8, node9, node10, node11, + node12); + case 5: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node7, node8, node9, node10, node11, + node12); + case 6: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node8, node9, node10, node11, + node12); + case 7: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node9, node10, node11, + node12); + case 8: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node, node10, node11, + node12); + case 9: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node11, + node12); + case 10: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node12); + case 11: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11, node12); + case 5: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11, node12); + case 6: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11, node12); + case 7: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11, node12); + case 8: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11, node12); + case 9: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11, node12); + case 10: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11, node12); + case 11: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node, node12); + case 12: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11, node12); + case 5: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11, node12); + case 6: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11, node12); + case 7: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11, node12); + case 8: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11, node12); + case 9: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11, node12); + case 10: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11, node12); + case 11: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node, node12); + case 12: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11, node12); + case 5: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11, node12); + case 6: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11, node12); + case 7: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11, node12); + case 8: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11, node12); + case 9: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11, node12); + case 10: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11, node12); + case 11: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node, node12); + case 12: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11, node12); + case 5: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11, node12); + case 6: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11, node12); + case 7: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11, node12); + case 8: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11, node12); + case 9: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11, node12); + case 10: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11, node12); + case 11: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node, node12); + case 12: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + + private Map5To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 10; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5); + case 1: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5); + case 2: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5); + case 3: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5); + case 4: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5); + case 1: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5); + case 2: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5); + case 3: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5); + case 4: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5); + case 5: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5); + case 1: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5); + case 2: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5); + case 3: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5); + case 4: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map5To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + + private Map5To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 11; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1); + case 1: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1); + case 2: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1); + case 3: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1); + case 4: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1); + case 1: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1); + case 2: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1); + case 3: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1); + case 4: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1); + case 5: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1); + case 1: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1); + case 2: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1); + case 3: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1); + case 4: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5); + case 1: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5); + case 2: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5); + case 3: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5); + case 4: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5); + case 5: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map5To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2); + case 2: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2); + case 3: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2); + case 4: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2); + case 2: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2); + case 3: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2); + case 4: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2); + case 5: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2); + case 2: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2); + case 3: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2); + case 4: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2); + case 1: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2); + case 2: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2); + case 3: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2); + case 4: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2); + case 5: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1); + case 1: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1); + case 2: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1); + case 3: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1); + case 4: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1); + case 5: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To3Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map5To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3); + case 4: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3); + case 2: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3); + case 3: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3); + case 4: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3); + case 5: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3); + case 2: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3); + case 3: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3); + case 4: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3); + case 5: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2); + case 2: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2); + case 3: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2); + case 4: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2); + case 5: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To4Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map5To4Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3, node4); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3, node4); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4); + case 4: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To5Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map5To5Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To6Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map5To6Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5, node6); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5, node6); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5, node6); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5, node6); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5, node6); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5, node6); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5, node6); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5, node6); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node6); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node6); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To7Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map5To7Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5, node6, node7); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5, node6, node7); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node6, node7); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node7); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5, node6, node7); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5, node6, node7); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5, node6, node7); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node6, node7); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node7); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To8Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map5To8Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5, node6, node7, node8); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node6, node7, node8); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node7, node8); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node8); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5, node6, node7, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5, node6, node7, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5, node6, node7, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5, node6, node7, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node6, node7, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node7, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To9Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map5To9Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node6, node7, node8, node9); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node7, node8, node9); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node8, node9); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node, node9); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To10Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map5To10Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node6, node7, node8, node9, + node10); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node7, node8, node9, + node10); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node8, node9, + node10); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node, node9, + node10); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node, + node10); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, + node10); + case 5: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, + node10); + case 6: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, + node10); + case 7: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, + node10); + case 8: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, + node10); + case 9: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, + node10); + case 10: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, + node10); + case 5: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, + node10); + case 6: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, + node10); + case 7: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, + node10); + case 8: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, + node10); + case 9: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, + node10); + case 10: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, + node10); + case 5: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, + node10); + case 6: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, + node10); + case 7: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, + node10); + case 8: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, + node10); + case 9: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, + node10); + case 10: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, + node10); + case 5: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, + node10); + case 6: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, + node10); + case 7: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, + node10); + case 8: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, + node10); + case 9: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, + node10); + case 10: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, + node10); + case 5: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, + node10); + case 6: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, + node10); + case 7: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, + node10); + case 8: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, + node10); + case 9: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, + node10); + case 10: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To11Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + + private Map5To11Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 21; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node11; + case 1: + return node10; + case 2: + return node9; + case 3: + return node8; + case 4: + return node7; + case 5: + return node6; + case 6: + return node5; + case 7: + return node4; + case 8: + return node3; + case 9: + return node2; + case 10: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 11; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf11x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 1: + return nodeOf11x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 2: + return nodeOf11x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 3: + return nodeOf11x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 4: + return nodeOf11x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 5: + return nodeOf11x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5, node6, node7, node8, node9, + node10, node11); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5, node6, node7, node8, node9, + node10, node11); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node6, node7, node8, node9, + node10, node11); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node7, node8, node9, + node10, node11); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node8, node9, + node10, node11); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node, node9, + node10, node11); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node, + node10, node11); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, + node11); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5, node6, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5, node6, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node6, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node8, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + + private Map6To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6); + case 1: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6); + case 2: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6); + case 3: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6); + case 4: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6); + case 5: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6); + case 1: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6); + case 2: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6); + case 3: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6); + case 4: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6); + case 5: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6); + case 6: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6); + case 1: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6); + case 2: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6); + case 3: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6); + case 4: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6); + case 5: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map6To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final CompactMapNode node1; + + private Map6To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1); + case 1: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1); + case 2: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1); + case 3: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1); + case 4: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1); + case 5: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 1: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 2: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 3: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1); + case 4: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1); + case 5: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1); + case 6: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1); + case 1: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1); + case 2: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1); + case 3: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1); + case 4: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1); + case 5: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6); + case 1: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6); + case 2: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6); + case 3: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6); + case 4: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6); + case 5: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6); + case 6: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map6To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2); + case 2: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2); + case 3: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2); + case 4: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2); + case 5: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2); + case 2: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2); + case 3: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2); + case 4: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2); + case 5: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2); + case 6: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2); + case 2: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2); + case 3: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2); + case 4: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2); + case 5: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2); + case 1: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2); + case 2: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2); + case 3: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2); + case 4: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2); + case 5: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2); + case 6: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1); + case 1: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1); + case 2: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1); + case 3: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1); + case 4: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1); + case 5: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1); + case 6: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To3Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map6To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3); + case 5: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3); + case 2: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3); + case 3: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3); + case 4: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3); + case 5: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3); + case 6: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3); + case 2: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3); + case 3: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3); + case 4: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3); + case 5: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3); + case 6: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2); + case 2: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2); + case 3: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2); + case 4: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2); + case 5: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2); + case 6: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To4Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map6To4Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3, node4); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4); + case 5: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To5Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map6To5Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4, node5); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4, node5); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4, node5); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node5); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4, node5); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4, node5); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4, node5); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4, node5); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4, node5); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4, node5); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node5); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node5); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To6Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map6To6Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4, node5, node6); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4, node5, node6); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4, node5, node6); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4, node5, node6); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4, node5, node6); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4, node5, node6); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node5, node6); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node5, node6); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node6); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node6); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To7Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map6To7Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4, node5, node6, node7); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node5, node6, node7); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node6, node7); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node7); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4, node5, node6, node7); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4, node5, node6, node7); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4, node5, node6, node7); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node5, node6, node7); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node6, node7); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node7); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To8Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map6To8Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node5, node6, node7, node8); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node6, node7, node8); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node7, node8); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node8); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4, node5, node6, node7, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4, node5, node6, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4, node5, node6, node7, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4, node5, node6, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4, node5, node6, node7, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4, node5, node6, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node5, node6, node7, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node5, node6, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node6, node7, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node6, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node7, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To9Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map6To9Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 21; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node5, node6, node7, node8, + node9); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node6, node7, node8, + node9); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node7, node8, + node9); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node8, + node9); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, + node9); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4, node5, node6, node7, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4, node5, node6, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4, node5, node6, node7, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4, node5, node6, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4, node5, node6, node7, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4, node5, node6, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node5, node6, node7, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node5, node6, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node6, node7, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node6, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node7, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To10Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map6To10Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 22; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 1: + return nodeOf10x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 2: + return nodeOf10x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 3: + return nodeOf10x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 4: + return nodeOf10x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + case 5: + return nodeOf10x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + case 6: + return nodeOf10x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node6, node7, node8, + node9, node10); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node7, node8, + node9, node10); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node8, + node9, node10); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, + node9, node10); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node, node10); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9, node10); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9, node10); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9, node10); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9, node10); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node, node10); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9, node10); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9, node10); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9, node10); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9, node10); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node, node10); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9, node10); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9, node10); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9, node10); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9, node10); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node, node10); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9, node10); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9, node10); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9, node10); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9, node10); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node, node10); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9, node10); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9, node10); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9, node10); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9, node10); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node, node10); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9, node10); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9, node10); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9, node10); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9, node10); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node, node10); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4, node5, node6, node7, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4, node5, node6, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4, node5, node6, node7, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4, node5, node6, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node5, node6, node7, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node5, node6, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node6, node7, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node6, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node7, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + + private Map7To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7); + case 1: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7); + case 2: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7); + case 3: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7); + case 4: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7); + case 5: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7); + case 6: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 1: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 2: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 3: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7); + case 4: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7); + case 5: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7); + case 6: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7); + case 7: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7); + case 1: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7); + case 2: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7); + case 3: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7); + case 4: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7); + case 5: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7); + case 6: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map7To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final CompactMapNode node1; + + private Map7To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + case 1: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + case 2: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + case 3: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1); + case 4: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1); + case 5: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1); + case 6: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 1: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 2: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 3: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 4: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1); + case 5: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1); + case 6: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1); + case 7: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1); + case 1: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1); + case 2: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1); + case 3: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1); + case 4: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1); + case 5: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1); + case 6: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7); + case 1: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7); + case 2: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7); + case 3: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7); + case 4: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7); + case 5: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7); + case 6: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7); + case 7: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map7To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2); + case 2: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2); + case 3: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2); + case 4: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2); + case 5: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2); + case 6: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 2: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 3: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 4: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2); + case 5: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2); + case 6: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2); + case 7: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2); + case 2: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2); + case 3: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2); + case 4: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2); + case 5: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2); + case 6: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2); + case 1: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2); + case 2: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2); + case 3: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2); + case 4: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2); + case 5: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2); + case 6: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2); + case 7: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 1: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 2: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 3: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 4: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1); + case 5: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1); + case 6: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1); + case 7: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To3Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map7To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3); + case 6: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3); + case 2: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3); + case 3: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3); + case 4: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3); + case 5: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3); + case 6: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3); + case 7: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3); + case 2: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3); + case 3: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3); + case 4: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3); + case 5: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3); + case 6: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3); + case 7: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 2: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 3: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 4: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2); + case 5: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2); + case 6: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2); + case 7: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To4Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map7To4Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3, node4); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3, node4); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4); + case 6: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3, node4); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3, node4); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node4); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3, node4); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3, node4); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3, node4); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3, node4); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3, node4); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3, node4); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node4); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node4); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node4); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To5Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map7To5Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3, node4, node5); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3, node4, node5); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node4, node5); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node5); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3, node4, node5); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3, node4, node5); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3, node4, node5); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3, node4, node5); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node4, node5); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node4, node5); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node5); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node5); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To6Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map7To6Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3, node4, node5, node6); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, node5, + node6); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6); + case 6: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3, node4, node5, + node6); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3, node4, node5, + node6); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3, node4, node5, + node6); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3, node4, node5, + node6); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node4, node5, + node6); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node4, node5, + node6); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node5, + node6); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node5, + node6); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node6); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node6); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To7Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map7To7Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 21; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3, node4, node5, node6, + node7); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3, node4, node5, node6, + node7); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node4, node5, node6, + node7); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node5, node6, + node7); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node6, + node7); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, + node7); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3, node4, node5, + node6, node7); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3, node4, node5, + node6, node7); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node4, node5, + node6, node7); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node5, + node6, node7); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node6, node7); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node7); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node6); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To8Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map7To8Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 22; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node4, node5, node6, + node7, node8); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node5, node6, + node7, node8); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node6, + node7, node8); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, + node7, node8); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node, node8); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To9Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map7To9Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 23; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 4: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 5: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 6: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 7: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node5, node6, + node7, node8, node9); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node6, + node7, node8, node9); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, + node7, node8, node9); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node, node8, node9); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node, node9); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node6, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node6, node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + + private Map8To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8); + case 6: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8); + case 7: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8); + case 6: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8); + case 7: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8); + case 8: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8); + case 6: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8); + case 7: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map8To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final CompactMapNode node1; + + private Map8To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 1: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 2: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 3: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 4: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1); + case 5: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1); + case 6: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1); + case 7: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 1: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 2: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 3: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 4: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 5: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1); + case 6: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1); + case 7: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1); + case 8: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1); + case 1: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1); + case 2: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1); + case 3: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1); + case 4: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1); + case 5: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1); + case 6: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1); + case 7: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8); + case 6: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8); + case 7: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8); + case 8: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map8To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 2: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 3: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 4: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2); + case 5: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2); + case 6: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2); + case 7: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 2: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 3: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 4: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 5: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2); + case 6: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2); + case 7: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2); + case 8: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 2: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 3: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 4: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2); + case 5: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2); + case 6: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2); + case 7: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2); + case 1: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2); + case 2: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2); + case 3: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2); + case 4: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2); + case 5: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2); + case 6: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2); + case 7: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2); + case 8: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 1: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 2: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 3: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 4: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 5: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1); + case 6: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1); + case 7: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1); + case 8: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To3Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map8To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2, node3); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2, node3); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, node3); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, node3); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3); + case 7: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2, node3); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node3); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3); + case 2: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3); + case 3: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3); + case 4: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3); + case 5: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2, node3); + case 6: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2, node3); + case 7: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2, node3); + case 8: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3); + case 2: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3); + case 3: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3); + case 4: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3); + case 5: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node3); + case 6: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node3); + case 7: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node3); + case 8: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 2: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 3: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 4: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 5: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2); + case 6: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2); + case 7: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2); + case 8: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To4Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map8To4Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2, node3, node4); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2, node3, node4); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, node3, + node4); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, node3, + node4); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4); + case 7: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2, node3, node4); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node3, node4); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node4); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2, node3, + node4); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2, node3, + node4); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2, node3, + node4); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node3, + node4); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node3, + node4); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node3, + node4); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node4); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node4); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node4); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To5Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map8To5Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 21; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2, node3, node4, + node5); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2, node3, node4, + node5); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, node3, + node4, node5); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5); + case 7: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2, node3, node4, + node5); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node3, node4, + node5); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node4, + node5); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node5); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2, node3, + node4, node5); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2, node3, + node4, node5); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node3, + node4, node5); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node3, + node4, node5); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node4, node5); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node4, node5); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node5); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node5); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To6Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map8To6Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 22; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2, node3, node4, + node5, node6); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, node3, + node4, node5, node6); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, node6); + case 7: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2, node3, node4, + node5, node6); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node3, node4, + node5, node6); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node4, + node5, node6); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node5, node6); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node, node6); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2, node3, + node4, node5, node6); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node3, + node4, node5, node6); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node4, node5, node6); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node5, node6); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node6); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node5); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To7Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map8To7Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 23; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2, node3, node4, + node5, node6, node7); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 7: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2, node3, node4, + node5, node6, node7); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node3, node4, + node5, node6, node7); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node4, + node5, node6, node7); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node5, node6, node7); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node, node6, node7); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node, node7); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2, node3, + node4, node5, node6, node7); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node3, + node4, node5, node6, node7); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node4, node5, node6, node7); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node5, node6, node7); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node6, node7); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node5, node7); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node5, node6); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To8Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map8To8Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 24; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7, node8); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7, node8); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2, node3, node4, + node5, node6, node7, node8); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2, node3, node4, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 3: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 4: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 5: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 6: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 7: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 8: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2, node3, node4, + node5, node6, node7, node8); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node3, node4, + node5, node6, node7, node8); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node4, + node5, node6, node7, node8); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node5, node6, node7, node8); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node, node6, node7, node8); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node, node7, node8); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node, node8); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + + private Map9To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 1: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 2: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 3: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 4: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9); + case 5: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9); + case 6: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9); + case 7: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9); + case 8: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 1: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 2: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 3: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 4: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 5: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9); + case 6: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9); + case 7: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9); + case 8: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9); + case 9: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 1: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 2: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 3: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 4: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9); + case 5: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9); + case 6: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9); + case 7: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9); + case 8: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map9To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final CompactMapNode node1; + + private Map9To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 1: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 2: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 3: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 4: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 5: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1); + case 6: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1); + case 7: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1); + case 8: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 1: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 2: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 3: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 4: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 5: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 6: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1); + case 7: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1); + case 8: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1); + case 9: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 1: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 2: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 3: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 4: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 5: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1); + case 6: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1); + case 7: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1); + case 8: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 1: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 2: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 3: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 4: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 5: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9); + case 6: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9); + case 7: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9); + case 8: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9); + case 9: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map9To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 2: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 3: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 4: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 5: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1, node2); + case 6: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1, node2); + case 7: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1, node2); + case 8: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 2: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 3: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 4: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2); + case 5: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2); + case 6: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2); + case 7: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2); + case 8: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2); + case 9: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 2: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 3: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 4: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 5: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2); + case 6: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2); + case 7: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2); + case 8: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node2); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2); + case 1: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2); + case 2: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2); + case 3: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2); + case 4: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2); + case 5: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, + node2); + case 6: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, + node2); + case 7: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, + node2); + case 8: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, + node2); + case 9: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + case 1: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + case 2: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + case 3: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + case 4: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + case 5: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + case 6: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, + node1); + case 7: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, + node1); + case 8: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, + node1); + case 9: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To3Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map9To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 21; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1, node2, node3); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1, node2, node3); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3); + case 8: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node2, node3); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node3); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3); + case 2: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3); + case 3: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3); + case 4: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3); + case 5: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3); + case 6: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node2, + node3); + case 7: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node2, + node3); + case 8: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node2, + node3); + case 9: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3); + case 2: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3); + case 3: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3); + case 4: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3); + case 5: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3); + case 6: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node3); + case 7: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node3); + case 8: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node3); + case 9: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2); + case 2: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2); + case 3: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2); + case 4: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2); + case 5: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2); + case 6: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2); + case 7: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2); + case 8: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2); + case 9: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To4Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map9To4Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 22; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1, node2, node3, + node4); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1, node2, node3, + node4); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4); + case 8: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node2, node3, + node4); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node3, + node4); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, + node4); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node2, + node3, node4); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node2, + node3, node4); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node2, + node3, node4); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node3, node4); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node3, node4); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node3, node4); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node4); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node4); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node4); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To5Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map9To5Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 23; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1, node2, node3, + node4, node5); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node5); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5); + case 8: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node2, node3, + node4, node5); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node3, + node4, node5); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, + node4, node5); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node, node5); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node2, + node3, node4, node5); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node2, + node3, node4, node5); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node2, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node3, node4, node5); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node3, node4, node5); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node4, node5); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node4, node5); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node5); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node5); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To6Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map9To6Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 24; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1, node2, node3, + node4, node5, node6); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node5, node6); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node6); + case 8: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node3, + node4, node5, node6); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, + node4, node5, node6); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node, node5, node6); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node, node6); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5, node6); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5, node6); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5, node6); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node2, + node3, node4, node5, node6); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node2, + node3, node4, node5, node6); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node2, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5, node6); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5, node6); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5, node6); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node3, node4, node5, node6); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node3, node4, node5, node6); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5, node6); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5, node6); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5, node6); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node4, node5, node6); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node4, node5, node6); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5, node6); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5, node6); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5, node6); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node5, node6); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node5, node6); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node6); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node6); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node6); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node6); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node6); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node5); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To7Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map9To7Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 25; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6, node7); + case 1: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6, node7); + case 2: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6, node7); + case 3: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6, node7); + case 4: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6, node7); + case 6: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6, node7); + case 7: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6, node7); + case 8: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node5, node6, node7); + case 9: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 8: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node3, + node4, node5, node6, node7); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, + node4, node5, node6, node7); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node, node5, node6, node7); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node, node6, node7); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node, node7); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5, node6, node7); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5, node6, node7); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5, node6, node7); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node2, + node3, node4, node5, node6, node7); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node2, + node3, node4, node5, node6, node7); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node2, + node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6, node7); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5, node6, node7); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5, node6, node7); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5, node6, node7); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node3, node4, node5, node6, node7); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node3, node4, node5, node6, node7); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6, node7); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6, node7); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6, node7); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6, node7); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5, node6, node7); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5, node6, node7); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5, node6, node7); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node4, node5, node6, node7); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node4, node5, node6, node7); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6, node7); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6, node7); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6, node7); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6, node7); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5, node6, node7); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5, node6, node7); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5, node6, node7); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node5, node6, node7); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node5, node6, node7); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6, node7); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6, node7); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6, node7); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6, node7); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node6, node7); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node6, node7); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node6, node7); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node6, node7); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node6, node7); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node7); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node7); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node7); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node7); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node7); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node7); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node7); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node7); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node5, node7); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node5, node6); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map10To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + + private Map10To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 1: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 2: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 3: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 4: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 5: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10); + case 6: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10); + case 7: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10); + case 8: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10); + case 9: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 1: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 2: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 3: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 4: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10); + case 5: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10); + case 6: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10); + case 7: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10); + case 8: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10); + case 9: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10); + case 10: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 1: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 2: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 3: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 4: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 5: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10); + case 6: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10); + case 7: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10); + case 8: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10); + case 9: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map10To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final CompactMapNode node1; + + private Map10To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 21; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 1: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 2: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 3: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 4: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 5: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 6: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, node1); + case 7: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, node1); + case 8: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, node1); + case 9: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 1: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 2: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 3: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 4: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + case 5: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + case 6: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + case 7: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1); + case 8: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1); + case 9: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1); + case 10: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 1: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 2: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 3: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 4: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 5: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 6: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1); + case 7: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1); + case 8: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1); + case 9: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10); + case 1: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10); + case 2: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10); + case 3: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10); + case 4: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10); + case 5: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10); + case 6: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10); + case 7: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10); + case 8: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10); + case 9: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10); + case 10: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map10To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map10To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 22; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + case 2: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + case 3: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + case 4: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + case 5: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + case 6: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, node1, + node2); + case 7: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, node1, + node2); + case 8: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, node1, + node2); + case 9: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2); + case 2: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2); + case 3: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2); + case 4: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + case 5: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + case 6: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + case 7: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2); + case 8: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2); + case 9: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2); + case 10: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2); + case 2: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2); + case 3: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2); + case 4: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2); + case 5: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2); + case 6: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2); + case 7: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2); + case 8: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2); + case 9: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, + node2); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2); + case 1: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2); + case 2: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2); + case 3: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2); + case 4: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2); + case 5: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2); + case 6: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node2); + case 7: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node2); + case 8: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node2); + case 9: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node2); + case 10: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1); + case 1: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1); + case 2: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1); + case 3: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1); + case 4: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + case 5: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + case 6: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + case 7: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1); + case 8: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1); + case 9: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1); + case 10: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map10To3Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map10To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 23; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, node1, + node2, node3); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, node1, + node2, node3); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3); + case 9: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, + node2, node3); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node, node3); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3); + case 2: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3); + case 3: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3); + case 4: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3); + case 5: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3); + case 6: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3); + case 7: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node2, node3); + case 8: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node2, node3); + case 9: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node2, node3); + case 10: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3); + case 2: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3); + case 3: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3); + case 4: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3); + case 5: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3); + case 6: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3); + case 7: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node3); + case 8: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node3); + case 9: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node3); + case 10: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2); + case 2: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2); + case 3: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2); + case 4: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + case 5: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + case 6: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + case 7: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2); + case 8: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2); + case 9: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2); + case 10: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map10To4Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map10To4Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 24; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, node1, + node2, node3, node4); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, node1, + node2, node3, node4); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node4); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node4); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4); + case 9: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, + node2, node3, node4); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node, node3, node4); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node, node4); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node2, node3, node4); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node2, node3, node4); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node2, node3, node4); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node3, node4); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node3, node4); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node3, node4); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node4); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node4); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node4); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map10To5Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map10To5Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 25; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, node1, + node2, node3, node4, node5); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node4, node5); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node5); + case 9: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, + node2, node3, node4, node5); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node, node3, node4, node5); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node, node4, node5); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node, node5); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node2, node3, node4, node5); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node2, node3, node4, node5); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node3, node4, node5); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node3, node4, node5); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node4, node5); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node4, node5); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node5); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node5); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node4); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node4); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map10To6Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map10To6Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 26; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, node1, + node2, node3, node4, node5, node6); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5, node6); + case 6: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5, node6); + case 7: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5, node6); + case 8: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node4, node5, node6); + case 9: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node4, node5, node6); + case 10: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node5, node6); + case 9: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node, node3, node4, node5, node6); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node, node4, node5, node6); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node, node5, node6); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node, node6); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5, node6); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5, node6); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5, node6); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5, node6); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5, node6); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5, node6); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5, node6); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5, node6); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node2, node3, node4, node5, node6); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node2, node3, node4, node5, node6); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5, node6); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5, node6); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5, node6); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5, node6); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5, node6); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5, node6); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5, node6); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5, node6); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node3, node4, node5, node6); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node3, node4, node5, node6); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5, node6); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5, node6); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5, node6); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5, node6); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5, node6); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5, node6); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5, node6); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5, node6); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node4, node5, node6); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node4, node5, node6); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5, node6); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5, node6); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5, node6); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5, node6); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5, node6); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5, node6); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5, node6); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5, node6); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node5, node6); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node5, node6); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node6); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node6); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node6); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node6); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node6); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node6); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node6); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node6); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node4, node6); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node4, node6); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node4, node5); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map11To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + + private Map11To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 22; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 11; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + case 1: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + case 2: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + case 3: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + case 4: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + case 5: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + case 6: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11); + case 7: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11); + case 8: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11); + case 9: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11); + case 10: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11); + case 1: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11); + case 2: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11); + case 3: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11); + case 4: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + case 5: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + case 6: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + case 7: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11); + case 8: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11); + case 9: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11); + case 10: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11); + case 11: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11); + case 1: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11); + case 2: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11); + case 3: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11); + case 4: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11); + case 5: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11); + case 6: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11); + case 7: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11); + case 8: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11); + case 9: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11); + case 10: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map11To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final CompactMapNode node1; + + private Map11To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 23; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 11; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 1: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 2: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 3: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 4: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 5: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 6: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 7: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, node1); + case 8: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, node1); + case 9: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, node1); + case 10: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1); + case 1: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1); + case 2: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1); + case 3: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1); + case 4: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 5: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 6: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 7: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 8: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1); + case 9: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1); + case 10: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, node1); + case 11: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 1: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 2: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 3: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 4: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 5: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 6: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 7: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1); + case 8: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1); + case 9: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1); + case 10: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11); + case 1: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11); + case 2: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11); + case 3: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11); + case 4: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + case 5: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + case 6: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + case 7: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11); + case 8: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11); + case 9: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11); + case 10: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11); + case 11: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map11To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map11To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 24; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 11; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 2: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 3: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 4: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 5: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 6: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 7: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, node1, node2); + case 8: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, node1, node2); + case 9: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, node1, node2); + case 10: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2); + case 2: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2); + case 3: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2); + case 4: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 5: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 6: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 7: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 8: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2); + case 9: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2); + case 10: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, node1, node2); + case 11: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 2: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 3: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 4: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 5: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 6: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 7: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2); + case 8: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2); + case 9: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, node1, + node2); + case 10: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node, node2); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2); + case 1: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2); + case 2: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2); + case 3: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2); + case 4: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2); + case 5: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2); + case 6: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2); + case 7: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node2); + case 8: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node2); + case 9: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node2); + case 10: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node2); + case 11: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1); + case 1: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1); + case 2: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1); + case 3: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1); + case 4: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 5: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 6: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 7: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 8: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1); + case 9: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1); + case 10: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1); + case 11: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map11To3Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map11To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 25; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 11; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, node1, node2, node3); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, node1, node2, node3); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node3); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, node1, node2, node3); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, node1, + node2, node3); + case 10: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node, node2, node3); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node, node3); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3); + case 2: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3); + case 3: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3); + case 4: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3); + case 5: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3); + case 6: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3); + case 7: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3); + case 8: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node2, node3); + case 9: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node2, node3); + case 10: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node2, node3); + case 11: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3); + case 2: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3); + case 3: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3); + case 4: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3); + case 5: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3); + case 6: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3); + case 7: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3); + case 8: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node3); + case 9: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node3); + case 10: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node3); + case 11: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2); + case 2: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2); + case 3: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2); + case 4: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 5: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 6: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 7: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 8: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2); + case 9: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2); + case 10: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node2); + case 11: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map11To4Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map11To4Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 26; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 11; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, node1, node2, node3, node4); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, node1, node2, node3, node4); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node3, node4); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, node1, node2, node3, node4); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node4); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, node1, + node2, node3, node4); + case 10: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node, node2, node3, node4); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node, node3, node4); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node, node4); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node2, node3, node4); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node2, node3, node4); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node2, node3, node4); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node3, node4); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node3, node4); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node3, node4); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node4); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node4); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node2, node4); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node3); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node2, node3); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map11To5Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map11To5Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 27; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 11; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, node1, node2, node3, node4, node5); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + case 7: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + case 8: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + case 9: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + case 10: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, node1, node2, node3, node4, node5); + case 11: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, node1, + node2, node3, node4, node5); + case 10: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node, node2, node3, node4, node5); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node, node3, node4, node5); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node, node4, node5); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node, node5); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4, node5); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4, node5); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4, node5); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4, node5); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4, node5); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4, node5); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4, node5); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4, node5); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node2, node3, node4, node5); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node2, node3, node4, node5); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node2, node3, node4, node5); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4, node5); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4, node5); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4, node5); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4, node5); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4, node5); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4, node5); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4, node5); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4, node5); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node3, node4, node5); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node3, node4, node5); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node3, node4, node5); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4, node5); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4, node5); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4, node5); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4, node5); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4, node5); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4, node5); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4, node5); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4, node5); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node4, node5); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node4, node5); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node2, node4, node5); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node5); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node5); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node5); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node5); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node5); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node5); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node5); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node5); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node5); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node3, node5); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node2, node3, node5); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node4); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node4); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node4); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node4); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node3, node4); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node2, node3, node4); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map12To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + + private Map12To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 24; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 12; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 1: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 2: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 3: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 4: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 5: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 6: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 7: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12); + case 8: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12); + case 9: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12); + case 10: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12); + case 11: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12); + case 1: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12); + case 2: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12); + case 3: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12); + case 4: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 5: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 6: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 7: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 8: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12); + case 9: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12); + case 10: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12); + case 11: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12); + case 12: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 1: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 2: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 3: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 4: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 5: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 6: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 7: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12); + case 8: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12); + case 9: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12); + case 10: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12); + case 11: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map12To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final CompactMapNode node1; + + private Map12To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 25; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 12; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 1: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 2: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 3: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 4: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 5: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 6: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 7: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 8: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, node1); + case 9: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, node1); + case 10: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, node1); + case 11: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1); + case 1: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1); + case 2: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1); + case 3: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1); + case 4: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 5: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 6: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 7: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 8: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 9: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1); + case 10: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, node1); + case 11: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, node1); + case 12: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 1: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 2: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 3: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 4: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 5: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 6: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 7: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 8: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1); + case 9: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, node1); + case 10: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, node1); + case 11: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12); + case 1: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12); + case 2: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12); + case 3: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12); + case 4: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 5: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 6: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 7: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 8: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12); + case 9: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12); + case 10: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12); + case 11: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12); + case 12: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map12To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map12To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 26; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 12; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 2: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 3: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 4: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 5: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 6: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 7: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 8: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, node1, node2); + case 9: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, node1, node2); + case 10: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, node1, node2); + case 11: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2); + case 2: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2); + case 3: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2); + case 4: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 5: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 6: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 7: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 8: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 9: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node2); + case 10: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, node1, node2); + case 11: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, node1, node2); + case 12: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 2: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 3: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 4: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 5: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 6: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 7: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 8: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2); + case 9: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, node1, node2); + case 10: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, node1, node2); + case 11: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node, node2); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2); + case 1: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2); + case 2: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2); + case 3: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2); + case 4: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2); + case 5: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2); + case 6: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2); + case 7: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2); + case 8: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node2); + case 9: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node2); + case 10: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node2); + case 11: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node2); + case 12: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1); + case 1: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1); + case 2: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1); + case 3: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1); + case 4: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 5: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 6: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 7: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 8: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 9: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1); + case 10: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node1); + case 11: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node1); + case 12: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map12To3Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map12To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 27; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 12; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, node1, node2, node3); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, node1, node2, node3); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3); + case 3: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3); + case 4: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 5: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 6: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 7: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 8: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 9: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 10: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, node1, node2, node3); + case 11: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, node1, node2, node3); + case 12: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, node1, node2, node3); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, node1, node2, node3); + case 11: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node, node2, node3); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node, node3); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3); + case 2: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3); + case 3: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3); + case 4: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3); + case 5: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3); + case 6: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3); + case 7: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3); + case 8: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3); + case 9: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node2, node3); + case 10: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node2, node3); + case 11: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node2, node3); + case 12: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3); + case 2: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3); + case 3: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3); + case 4: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3); + case 5: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3); + case 6: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3); + case 7: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3); + case 8: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3); + case 9: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node3); + case 10: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node1, node3); + case 11: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node1, node3); + case 12: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2); + case 2: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2); + case 3: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2); + case 4: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 5: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 6: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 7: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 8: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 9: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node2); + case 10: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node1, node2); + case 11: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node1, node2); + case 12: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map12To4Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map12To4Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 28; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 12; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, node1, node2, node3, node4); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, node1, node2, node3, node4); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3, node4); + case 1: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3, node4); + case 2: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3, node4); + case 3: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3, node4); + case 4: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + case 5: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + case 6: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + case 7: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + case 8: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + case 9: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + case 10: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, node1, node2, node3, node4); + case 11: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, node1, node2, node3, node4); + case 12: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, node1, node2, node3, node4); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, node1, node2, node3, node4); + case 11: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node, node2, node3, node4); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node, node3, node4); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node, node4); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3, node4); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3, node4); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3, node4); + case 3: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3, node4); + case 4: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3, node4); + case 5: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3, node4); + case 6: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3, node4); + case 7: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3, node4); + case 8: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3, node4); + case 9: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node2, node3, node4); + case 10: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node2, node3, node4); + case 11: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node2, node3, node4); + case 12: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3, node4); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3, node4); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3, node4); + case 3: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3, node4); + case 4: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3, node4); + case 5: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3, node4); + case 6: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3, node4); + case 7: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3, node4); + case 8: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3, node4); + case 9: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node3, node4); + case 10: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node1, node3, node4); + case 11: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node1, node3, node4); + case 12: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node4); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node4); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node4); + case 3: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node4); + case 4: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node4); + case 5: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node4); + case 6: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node4); + case 7: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node4); + case 8: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node4); + case 9: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node2, node4); + case 10: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node1, node2, node4); + case 11: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node1, node2, node4); + case 12: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node3); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node3); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node3); + case 3: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node3); + case 4: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 5: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 6: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 7: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 8: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 9: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 10: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node1, node2, node3); + case 11: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node1, node2, node3); + case 12: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map13To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + + private Map13To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final K key13, final V val13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 26; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 13; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 1: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 2: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 3: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 4: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 5: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 6: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 7: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 8: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13); + case 9: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13); + case 10: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13); + case 11: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13); + case 12: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13); + case 1: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13); + case 2: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13); + case 3: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13); + case 4: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 5: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 6: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 7: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 8: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 9: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13); + case 10: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13); + case 11: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13); + case 12: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13); + case 13: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 1: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 2: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 3: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 4: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 5: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 6: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 7: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 8: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13); + case 9: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13); + case 10: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13); + case 11: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13); + case 12: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map13To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final CompactMapNode node1; + + private Map13To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final K key13, final V val13, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 27; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 13; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 1: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 2: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 3: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 4: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 5: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 6: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 7: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 8: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 9: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, node1); + case 10: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, node1); + case 11: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, node1); + case 12: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1); + case 1: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1); + case 2: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1); + case 3: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1); + case 4: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 5: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 6: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 7: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 8: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 9: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 10: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, node1); + case 11: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, node1); + case 12: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, node1); + case 13: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 1: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 2: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 3: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 4: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 5: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 6: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 7: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 8: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 9: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, node1); + case 10: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, node1); + case 11: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, node1); + case 12: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13); + case 1: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13); + case 2: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13); + case 3: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13); + case 4: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 5: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 6: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 7: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 8: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 9: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13); + case 10: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13); + case 11: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13); + case 12: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13); + case 13: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map13To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map13To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final K key13, final V val13, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 28; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 13; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 2: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 3: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 4: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 5: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 6: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 7: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 8: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 9: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, node1, node2); + case 10: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, node1, node2); + case 11: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, node1, node2); + case 12: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2); + case 2: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2); + case 3: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2); + case 4: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 5: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 6: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 7: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 8: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 9: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 10: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, node1, node2); + case 11: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, node1, node2); + case 12: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, node1, node2); + case 13: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 2: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 3: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 4: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 5: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 6: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 7: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 8: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 9: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, node1, node2); + case 10: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, node1, node2); + case 11: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, node1, node2); + case 12: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node, node2); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2); + case 1: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2); + case 2: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2); + case 3: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2); + case 4: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2); + case 5: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2); + case 6: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2); + case 7: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2); + case 8: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2); + case 9: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node2); + case 10: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, node2); + case 11: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, node2); + case 12: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, node2); + case 13: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1); + case 1: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1); + case 2: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1); + case 3: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1); + case 4: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 5: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 6: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 7: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 8: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 9: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 10: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, node1); + case 11: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, node1); + case 12: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, node1); + case 13: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map13To3Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map13To3Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final K key13, final V val13, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 29; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 13; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 3: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 4: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 5: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 6: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 7: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 8: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 9: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 10: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, node1, node2, node3); + case 11: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, node1, node2, node3); + case 12: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 1: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 2: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 3: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 4: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 5: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 6: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 7: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 8: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 9: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 10: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 11: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, node1, node2, node3); + case 12: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, node1, node2, node3); + case 13: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, node1, node2, node3); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, node1, node2, node3); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, node1, node2, node3); + case 12: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node, node2, node3); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node, node3); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 2: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 3: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 4: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 5: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 6: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 7: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 8: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 9: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 10: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, node2, node3); + case 11: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, node2, node3); + case 12: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, node2, node3); + case 13: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 2: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 3: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 4: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 5: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 6: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 7: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 8: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 9: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 10: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, node1, node3); + case 11: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, node1, node3); + case 12: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, node1, node3); + case 13: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 2: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 3: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 4: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 5: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 6: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 7: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 8: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 9: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 10: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, node1, node2); + case 11: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, node1, node2); + case 12: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, node1, node2); + case 13: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map14To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + + private Map14To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final K key13, final V val13, final K key14, final V val14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 28; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + case 13: + return key14; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + case 13: + return val14; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + case 13: + return (java.util.Map.Entry) entryOf(key14, val14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 14; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 1: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 2: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 3: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 4: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 5: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 6: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 7: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 8: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 9: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, key14, val14); + case 10: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, key14, val14); + case 11: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, key14, val14); + case 12: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, key14, val14); + case 13: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x15(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14); + case 1: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14); + case 2: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14); + case 3: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14); + case 4: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 5: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 6: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 7: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 8: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 9: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 10: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, key14, val14); + case 11: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, key14, val14); + case 12: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, key14, val14); + case 13: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, key14, val14); + case 14: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 1: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 2: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 3: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 4: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 5: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 6: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 7: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 8: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 9: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, key14, val14); + case 10: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, key14, val14); + case 11: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, key14, val14); + case 12: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key14, val14); + case 13: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map14To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final CompactMapNode node1; + + private Map14To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final K key13, final V val13, final K key14, final V val14, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 29; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + case 13: + return key14; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + case 13: + return val14; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + case 13: + return (java.util.Map.Entry) entryOf(key14, val14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 14; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 1: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 2: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 3: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 4: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 5: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 6: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 7: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 8: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 9: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 10: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, key14, val14, node1); + case 11: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, key14, val14, node1); + case 12: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, key14, val14, node1); + case 13: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 1: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 2: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 3: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 4: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 5: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 6: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 7: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 8: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 9: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 10: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 11: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, key14, val14, node1); + case 12: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, key14, val14, node1); + case 13: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, key14, val14, node1); + case 14: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 1: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 2: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 3: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 4: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 5: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 6: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 7: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 8: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 9: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, key14, val14, node1); + case 10: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, key14, val14, node1); + case 11: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, key14, val14, node1); + case 12: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key14, val14, node1); + case 13: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x15(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 1: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 2: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 3: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 4: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 5: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 6: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 7: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 8: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 9: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 10: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, key14, val14); + case 11: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, key14, val14); + case 12: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, key14, val14); + case 13: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, key14, val14); + case 14: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map14To2Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map14To2Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final K key13, final V val13, final K key14, final V val14, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 30; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + case 13: + return key14; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + case 13: + return val14; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + case 13: + return (java.util.Map.Entry) entryOf(key14, val14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 14; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 2: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 3: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 4: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 5: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 6: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 7: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 8: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 9: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 10: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, key14, val14, node1, node2); + case 11: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, key14, val14, node1, node2); + case 12: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, key14, val14, node1, node2); + case 13: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x15(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 1: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 2: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 3: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 4: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 5: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 6: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 7: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 8: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 9: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 10: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 11: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, key14, val14, node1, node2); + case 12: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, key14, val14, node1, node2); + case 13: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, key14, val14, node1, node2); + case 14: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 2: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 3: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 4: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 5: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 6: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 7: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 8: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 9: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, key14, val14, node1, node2); + case 10: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, key14, val14, node1, node2); + case 11: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, key14, val14, node1, node2); + case 12: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key14, val14, node1, node2); + case 13: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node, node2); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 1: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 2: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 3: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 4: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 5: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 6: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 7: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 8: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 9: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 10: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 11: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, key14, val14, node2); + case 12: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, key14, val14, node2); + case 13: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, key14, val14, node2); + case 14: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 1: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 2: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 3: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 4: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 5: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 6: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 7: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 8: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 9: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 10: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 11: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, key14, val14, node1); + case 12: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, key14, val14, node1); + case 13: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, key14, val14, node1); + case 14: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map15To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + + private Map15To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final K key13, final V val13, final K key14, final V val14, final K key15, + final V val15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 30; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + case 13: + return key14; + case 14: + return key15; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + case 13: + return val14; + case 14: + return val15; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + case 13: + return (java.util.Map.Entry) entryOf(key14, val14); + case 14: + return (java.util.Map.Entry) entryOf(key15, val15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 15; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 1: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 2: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 3: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 4: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 5: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 6: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 7: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 8: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 9: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 10: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, key14, val14, key15, val15); + case 11: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, key14, val14, key15, val15); + case 12: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, key14, val14, key15, val15); + case 13: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val, key15, val15); + case 14: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x16(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 1: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 2: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 3: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 4: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 5: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 6: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 7: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 8: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 9: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 10: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 11: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, key14, val14, key15, val15); + case 12: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, key14, val14, key15, val15); + case 13: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, key14, val14, key15, val15); + case 14: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key, val, key15, val15); + case 15: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x14(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 1: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 2: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 3: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 4: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 5: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 6: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 7: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 8: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 9: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, key14, val14, key15, val15); + case 10: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, key14, val14, key15, val15); + case 11: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, key14, val14, key15, val15); + case 12: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key14, val14, key15, val15); + case 13: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key15, val15); + case 14: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 14: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map15To1Node_5Bits_Spec0To16 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final CompactMapNode node1; + + private Map15To1Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final K key13, final V val13, final K key14, final V val14, final K key15, + final V val15, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 31; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + case 13: + return key14; + case 14: + return key15; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + case 13: + return val14; + case 14: + return val15; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + case 13: + return (java.util.Map.Entry) entryOf(key14, val14); + case 14: + return (java.util.Map.Entry) entryOf(key15, val15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator> nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 15; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 1: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 2: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 3: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 4: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 5: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 6: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 7: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 8: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 9: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 10: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 11: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, key14, val14, key15, val15, node1); + case 12: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, key14, val14, key15, val15, node1); + case 13: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val, key15, val15, node1); + case 14: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x16(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 1: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 2: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 3: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 4: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 5: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 6: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 7: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 8: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 9: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 10: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 11: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 12: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, key14, val14, key15, val15, node1); + case 13: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, key14, val14, key15, val15, node1); + case 14: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key, val, key15, val15, node1); + case 15: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 1: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 2: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 3: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 4: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 5: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 6: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 7: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 8: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 9: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, key14, val14, key15, val15, node1); + case 10: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, key14, val14, key15, val15, node1); + case 11: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, key14, val14, key15, val15, node1); + case 12: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key14, val14, key15, val15, node1); + case 13: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key15, val15, node1); + case 14: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 14: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x16(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, + val15); + case 1: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, + val15); + case 2: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, + val15); + case 3: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, + val15); + case 4: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 5: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 6: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 7: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 8: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 9: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 10: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 11: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, key14, val14, key15, val15); + case 12: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, key14, val14, key15, val15); + case 13: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, key14, val14, key15, val15); + case 14: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key, val, key15, val15); + case 15: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map16To0Node_5Bits_Spec0To16 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + private final K key9; + private final V val9; + private final K key10; + private final V val10; + private final K key11; + private final V val11; + private final K key12; + private final V val12; + private final K key13; + private final V val13; + private final K key14; + private final V val14; + private final K key15; + private final V val15; + private final K key16; + private final V val16; + + private Map16To0Node_5Bits_Spec0To16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8, final K key9, + final V val9, final K key10, final V val10, final K key11, final V val11, final K key12, + final V val12, final K key13, final V val13, final K key14, final V val14, final K key15, + final V val15, final K key16, final V val16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 32; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + K getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + case 13: + return key14; + case 14: + return key15; + case 15: + return key16; + default: + throw new IllegalStateException("Index out of range."); + } + } + + V getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + case 13: + return val14; + case 14: + return val15; + case 15: + return val16; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + case 13: + return (java.util.Map.Entry) entryOf(key14, val14); + case 14: + return (java.util.Map.Entry) entryOf(key15, val15); + case 15: + return (java.util.Map.Entry) entryOf(key16, val16); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator> nodeIterator() { + return Collections.>emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 16; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 1: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 2: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 3: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 4: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 5: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 6: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 7: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 8: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 9: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 10: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 11: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, key14, val14, key15, val15, key16, val16); + case 12: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, key14, val14, key15, val15, key16, val16); + case 13: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val, key15, val15, key16, val16); + case 14: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val, key16, val16); + case 15: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x17(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 1: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 2: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 3: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 4: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 5: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 6: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 7: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 8: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 9: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 10: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 11: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 12: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, key14, val14, key15, val15, key16, + val16); + case 13: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, key14, val14, key15, val15, key16, + val16); + case 14: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key, val, key15, val15, key16, + val16); + case 15: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key, val, key16, + val16); + case 16: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, key, + val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x15(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 1: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 2: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 3: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 4: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 5: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 6: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 7: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 8: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 9: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 10: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 11: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, key14, val14, key15, val15, key16, val16); + case 12: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key14, val14, key15, val15, key16, val16); + case 13: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key15, val15, key16, val16); + case 14: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key16, val16); + case 15: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 14: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 15: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieMap_5Bits_Spec0To16_IntKey_IntValue.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieMap_5Bits_Spec0To16_IntKey_IntValue.java new file mode 100644 index 0000000..652c7d5 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieMap_5Bits_Spec0To16_IntKey_IntValue.java @@ -0,0 +1,95064 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.specialized; + +import java.text.DecimalFormat; +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.atomic.AtomicReference; + +import io.usethesource.capsule.Map; +import io.usethesource.capsule.util.iterator.ArrayIterator; + +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +@SuppressWarnings("rawtypes") +public class TrieMap_5Bits_Spec0To16_IntKey_IntValue + implements Map.Immutable { + + @SuppressWarnings("unchecked") + private static final TrieMap_5Bits_Spec0To16_IntKey_IntValue EMPTY_MAP = + new TrieMap_5Bits_Spec0To16_IntKey_IntValue(CompactMapNode.emptyTrieNodeConstant(), 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractMapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieMap_5Bits_Spec0To16_IntKey_IntValue(AbstractMapNode rootNode, int hashCode, int cachedSize) { + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + @SuppressWarnings("unchecked") + public static final Map.Immutable of() { + return TrieMap_5Bits_Spec0To16_IntKey_IntValue.EMPTY_MAP; + } + + @SuppressWarnings("unchecked") + public static final Map.Immutable of( + Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + Map.Immutable result = + TrieMap_5Bits_Spec0To16_IntKey_IntValue.EMPTY_MAP; + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final int key = (int) keyValuePairs[i]; + final int val = (int) keyValuePairs[i + 1]; + + result = result.__put(key, val); + } + + return result; + } + + @SuppressWarnings("unchecked") + public static final Map.Transient transientOf() { + return TrieMap_5Bits_Spec0To16_IntKey_IntValue.EMPTY_MAP.asTransient(); + } + + @SuppressWarnings("unchecked") + public static final Map.Transient transientOf( + Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + final Map.Transient result = + TrieMap_5Bits_Spec0To16_IntKey_IntValue.EMPTY_MAP.asTransient(); + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final int key = (int) keyValuePairs[i]; + final int val = (int) keyValuePairs[i + 1]; + + result.__put(key, val); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = + entryIterator(); it.hasNext();) { + final java.util.Map.Entry entry = it.next(); + final int key = entry.getKey(); + final int val = entry.getValue(); + + hash += (int) key ^ (int) val; + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + public boolean containsKey(final Object o) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + return rootNode.containsKey(key, transformHashCode(key), 0); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + return rootNode.containsKey(key, transformHashCode(key), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + public java.lang.Integer get(final Object o) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public java.lang.Integer getEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public Map.Immutable __put(final java.lang.Integer key, + final java.lang.Integer val) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = (int) details.getReplacedValue(); + final int valHashNew = (int) val; + + return new TrieMap_5Bits_Spec0To16_IntKey_IntValue(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = (int) val; + return new TrieMap_5Bits_Spec0To16_IntKey_IntValue(newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + public Map.Immutable __putEquivalent( + final java.lang.Integer key, final java.lang.Integer val, final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = (int) details.getReplacedValue(); + final int valHashNew = (int) val; + + return new TrieMap_5Bits_Spec0To16_IntKey_IntValue(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = (int) val; + return new TrieMap_5Bits_Spec0To16_IntKey_IntValue(newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + public Map.Immutable __putAll( + final java.util.Map map) { + final Map.Transient tmpTransient = this.asTransient(); + tmpTransient.__putAll(map); + return tmpTransient.freeze(); + } + + public Map.Immutable __putAllEquivalent( + final java.util.Map map, + final Comparator cmp) { + final Map.Transient tmpTransient = this.asTransient(); + tmpTransient.__putAllEquivalent(map, cmp); + return tmpTransient.freeze(); + } + + public Map.Immutable __remove(final java.lang.Integer key) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = (int) details.getReplacedValue(); + return new TrieMap_5Bits_Spec0To16_IntKey_IntValue(newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + public Map.Immutable __removeEquivalent( + final java.lang.Integer key, final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = (int) details.getReplacedValue(); + return new TrieMap_5Bits_Spec0To16_IntKey_IntValue(newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + public java.lang.Integer put(final java.lang.Integer key, final java.lang.Integer val) { + throw new UnsupportedOperationException(); + } + + public void putAll(final java.util.Map m) { + throw new UnsupportedOperationException(); + } + + public void clear() { + throw new UnsupportedOperationException(); + } + + public java.lang.Integer remove(final Object key) { + throw new UnsupportedOperationException(); + } + + public int size() { + return cachedSize; + } + + public boolean isEmpty() { + return cachedSize == 0; + } + + public Iterator keyIterator() { + return new MapKeyIterator(rootNode); + } + + public Iterator valueIterator() { + return new MapValueIterator(rootNode); + } + + public Iterator> entryIterator() { + return new MapEntryIterator(rootNode); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.keyIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.valueIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = + entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public java.util.Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_Spec0To16_IntKey_IntValue.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) + return false; + + for (@SuppressWarnings("unchecked") + Iterator it = that.entrySet().iterator(); it.hasNext();) { + java.util.Map.Entry entry = it.next(); + + try { + @SuppressWarnings("unchecked") + final int key = (java.lang.Integer) entry.getKey(); + final Optional result = + rootNode.findByKey(key, transformHashCode(key), 0); + + if (!result.isPresent()) { + return false; + } else { + @SuppressWarnings("unchecked") + final int val = (java.lang.Integer) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public Map.Transient asTransient() { + return new TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractMapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator nodeIterator() { + return new TrieMap_5Bits_Spec0To16_IntKey_IntValueNodeIterator(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. Payload X Node + */ + protected int[][] arityCombinationsHistogram() { + final Iterator it = nodeIterator(); + final int[][] sumArityCombinations = new int[33][33]; + + while (it.hasNext()) { + final AbstractMapNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[33]; + + final int maxArity = 32; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[33]; + for (int cumsum = 0, i = 0; i < 33; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 33; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + abstract static class Optional { + private static final Optional EMPTY = new Optional() { + @Override + boolean isPresent() { + return false; + } + + @Override + Object get() { + return null; + } + }; + + @SuppressWarnings("unchecked") + static Optional empty() { + return EMPTY; + } + + static Optional of(T value) { + return new Value(value); + } + + abstract boolean isPresent(); + + abstract T get(); + + private static final class Value extends Optional { + private final T value; + + private Value(T value) { + this.value = value; + } + + @Override + boolean isPresent() { + return true; + } + + @Override + T get() { + return value; + } + } + } + + static final class MapResult { + private int replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(int replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static MapResult unchanged() { + return new MapResult(); + } + + private MapResult() {} + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public int getReplacedValue() { + return replacedValue; + } + } + + protected static interface INode { + } + + protected static abstract class AbstractMapNode + implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final int key, final int keyHash, final int shift); + + abstract boolean containsKey(final int key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final int key, final int keyHash, + final int shift); + + abstract Optional findByKey(final int key, final int keyHash, + final int shift, final Comparator cmp); + + abstract CompactMapNode updated(final AtomicReference mutator, final int key, + final int val, final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode updated(final AtomicReference mutator, final int key, + final int val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + abstract CompactMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractMapNode getNode(final int index); + + @Deprecated + Iterator nodeIterator() { + return new Iterator() { + + int nextIndex = 0; + final int nodeArity = AbstractMapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) + throw new NoSuchElementException(); + return AbstractMapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract int getKey(final int index); + + abstract int getValue(final int index); + + abstract java.util.Map.Entry getKeyValueEntry( + final int index); + + @Deprecated + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + int size() { + final Iterator it = new MapKeyIterator(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactMapNode extends AbstractMapNode { + + static final int hashCodeLength() { + return 32; + } + + static final int bitPartitionSize() { + return 5; + } + + static final int bitPartitionMask() { + return 0b11111; + } + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & bitPartitionMask(); + } + + static final int bitpos(final int mask) { + return (int) (1 << mask); + } + + abstract int nodeMap(); + + abstract int dataMap(); + + enum ContentType { + KEY, VAL, RARE_KEY, RARE_VAL, NODE, SLOT + } + + int logicalToPhysicalIndex(final ContentType type, final int index) { + final int physicalIndex; + + switch (type) { + case KEY: + physicalIndex = TUPLE_LENGTH * index; + break; + case VAL: + physicalIndex = TUPLE_LENGTH * index + 1; + break; + case RARE_KEY: + physicalIndex = + TUPLE_LENGTH * index + TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap()); + break; + case RARE_VAL: + physicalIndex = + TUPLE_LENGTH * index + TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap()) + 1; + break; + case NODE: + physicalIndex = slotArity() - 1 - index; + break; + case SLOT: + physicalIndex = index; + break; + default: + throw new IllegalStateException("Cases not exhausted?"); + } + + return physicalIndex; + } + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + @Override + abstract CompactMapNode getNode(final int index); + + abstract CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val); + + abstract CompactMapNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final int key, final int val); + + abstract CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos); + + abstract CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node); + + CompactMapNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + static final CompactMapNode mergeTwoKeyValPairs(final int key0, final int val0, + final int keyHash0, final int key1, final int val1, final int keyHash1, final int shift) { + assert !(key0 == key1); + + if (shift >= hashCodeLength()) { + // throw new + // IllegalStateException("Hash collision not yet fixed."); + return new HashCollisionMapNode_5Bits_Spec0To16_IntKey_IntValue(keyHash0, + (int[]) new int[] {key0, key1}, (int[]) new int[] {val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int dataMap = (int) (bitpos(mask0) | bitpos(mask1)); + + if (mask0 < mask1) { + return nodeOf(null, (int) 0, dataMap, key0, val0, key1, val1); + } else { + return nodeOf(null, (int) 0, dataMap, key1, val1, key0, val0); + } + } else { + final CompactMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, keyHash1, + shift + bitPartitionSize()); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf(null, nodeMap, (int) 0, node); + } + } + + static final CompactMapNode emptyTrieNodeConstant() { + return EMPTY_NODE; + } + + static final CompactMapNode EMPTY_NODE; + + static { + + EMPTY_NODE = new Map0To0Node_5Bits_Spec0To16_IntKey_IntValue(null, (int) 0, (int) 0); + + }; + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + return new BitmapIndexedMapNode(mutator, nodeMap, dataMap, nodes); + } + + @SuppressWarnings("unchecked") + static final CompactMapNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + return EMPTY_NODE; + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1) { + return new Map0To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2) { + return new Map0To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map0To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map0To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + return new Map0To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map0To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map0To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8) { + return new Map0To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map0To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map0To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11) { + return new Map0To11Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + return new Map0To12Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13) { + return new Map0To13Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, final CompactMapNode node14) { + return new Map0To14Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15) { + return new Map0To15Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14, node15); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15, final CompactMapNode node16) { + return new Map0To16Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14, node15, node16); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15, final CompactMapNode node16, final CompactMapNode node17) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[] {node17, node16, node15, node14, node13, + node12, node11, node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1) { + return new Map1To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1) { + return new Map1To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map1To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map1To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + return new Map1To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map1To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map1To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + return new Map1To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + return new Map1To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + return new Map1To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10) { + return new Map1To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + return new Map1To11Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + return new Map1To12Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13) { + return new Map1To13Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14) { + return new Map1To14Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13, node14); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15) { + return new Map1To15Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13, node14, node15); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15, final CompactMapNode node16) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, node16, node15, node14, node13, node12, node11, node10, node9, + node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2) { + return new Map2To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1) { + return new Map2To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map2To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + return new Map2To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map2To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map2To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6) { + return new Map2To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map2To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map2To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9) { + return new Map2To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + return new Map2To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11) { + return new Map2To11Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12) { + return new Map2To12Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13) { + return new Map2To13Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14) { + return new Map2To14Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13, node14); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, final CompactMapNode node15) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, node15, node14, node13, node12, node11, node10, + node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3) { + return new Map3To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1) { + return new Map3To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2) { + return new Map3To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map3To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map3To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + return new Map3To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map3To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map3To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8) { + return new Map3To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map3To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map3To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11) { + return new Map3To11Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + return new Map3To12Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11, node12); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13) { + return new Map3To13Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11, node12, node13); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, final CompactMapNode node14) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, node14, node13, node12, node11, node10, + node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4) { + return new Map4To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1) { + return new Map4To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map4To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map4To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + return new Map4To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map4To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map4To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + return new Map4To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + return new Map4To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, + node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + return new Map4To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10) { + return new Map4To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + return new Map4To11Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + return new Map4To12Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10, node11, node12); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, node13, node12, node11, + node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5) { + return new Map5To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1) { + return new Map5To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2) { + return new Map5To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map5To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map5To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + return new Map5To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map5To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map5To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, + node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8) { + return new Map5To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, + node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map5To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map5To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11) { + return new Map5To11Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, node12, node11, + node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6) { + return new Map6To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1) { + return new Map6To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map6To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map6To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + return new Map6To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map6To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, + node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map6To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, + node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + return new Map6To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, + node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + return new Map6To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, + node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + return new Map6To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, + node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10) { + return new Map6To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + node11, node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7) { + return new Map7To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1) { + return new Map7To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map7To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + return new Map7To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map7To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map7To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6) { + return new Map7To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map7To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map7To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9) { + return new Map7To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8) { + return new Map8To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1) { + return new Map8To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, + node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2) { + return new Map8To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map8To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map8To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + return new Map8To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map8To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map8To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8) { + return new Map8To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, node9, node8, node7, node6, node5, node4, node3, node2, + node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9) { + return new Map9To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, + final CompactMapNode node1) { + return new Map9To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map9To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map9To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + return new Map9To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map9To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map9To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + return new Map9To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, node8, node7, node6, node5, node4, node3, node2, + node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10) { + return new Map10To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1) { + return new Map10To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1, final CompactMapNode node2) { + return new Map10To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map10To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map10To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + return new Map10To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map10To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, node7, node6, node5, node4, node3, + node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11) { + return new Map11To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final CompactMapNode node1) { + return new Map11To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map11To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map11To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + return new Map11To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map11To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, node6, node5, node4, + node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12) { + return new Map12To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final CompactMapNode node1) { + return new Map12To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map12To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + return new Map12To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map12To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, node5, + node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13) { + return new Map13To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final CompactMapNode node1) { + return new Map13To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final CompactMapNode node1, final CompactMapNode node2) { + return new Map13To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map13To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14) { + return new Map14To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, key14, val14); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, + final CompactMapNode node1) { + return new Map14To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map14To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15) { + return new Map15To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final CompactMapNode node1) { + return new Map15To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, + node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final CompactMapNode node1, final CompactMapNode node2) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final int key16, final int val16) { + return new Map16To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, + key16, val16); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final int key16, final int val16, final CompactMapNode node1) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final int key16, final int val16, final int key17, final int val17) { + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, key17, val17}); + } + + static final CompactMapNode nodeOf0x0(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + return EMPTY_NODE; + } + + static final CompactMapNode nodeOf1x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1) { + return new Map0To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1); + } + + static final CompactMapNode nodeOf2x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2) { + return new Map0To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2); + } + + static final CompactMapNode nodeOf3x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map0To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3); + } + + static final CompactMapNode nodeOf4x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map0To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4); + } + + static final CompactMapNode nodeOf5x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + return new Map0To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map0To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map0To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8) { + return new Map0To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map0To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf10x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map0To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf11x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11) { + return new Map0To11Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf12x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + return new Map0To12Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + } + + static final CompactMapNode nodeOf13x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13) { + return new Map0To13Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + } + + static final CompactMapNode nodeOf14x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, final CompactMapNode node14) { + return new Map0To14Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + } + + static final CompactMapNode nodeOf15x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15) { + return new Map0To15Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14, node15); + } + + static final CompactMapNode nodeOf16x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15, final CompactMapNode node16) { + return new Map0To16Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14, node15, node16); + } + + static final CompactMapNode nodeOf17x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15, final CompactMapNode node16, final CompactMapNode node17) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[] {node17, node16, node15, node14, node13, + node12, node11, node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf18x0(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15, final CompactMapNode node16, final CompactMapNode node17, + final CompactMapNode node18) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {node18, node17, node16, node15, node14, node13, node12, node11, node10, + node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1) { + return new Map1To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1); + } + + static final CompactMapNode nodeOf1x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1) { + return new Map1To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1); + } + + static final CompactMapNode nodeOf2x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map1To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2); + } + + static final CompactMapNode nodeOf3x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map1To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3); + } + + static final CompactMapNode nodeOf4x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + return new Map1To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map1To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map1To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + return new Map1To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + return new Map1To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + return new Map1To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf10x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10) { + return new Map1To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf11x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + return new Map1To11Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf12x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + return new Map1To12Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + } + + static final CompactMapNode nodeOf13x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13) { + return new Map1To13Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + } + + static final CompactMapNode nodeOf14x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14) { + return new Map1To14Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13, node14); + } + + static final CompactMapNode nodeOf15x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15) { + return new Map1To15Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13, node14, node15); + } + + static final CompactMapNode nodeOf16x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15, final CompactMapNode node16) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, node16, node15, node14, node13, node12, node11, node10, node9, + node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf17x1(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15, final CompactMapNode node16, + final CompactMapNode node17) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, node17, node16, node15, node14, node13, node12, node11, node10, + node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2) { + return new Map2To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2); + } + + static final CompactMapNode nodeOf1x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1) { + return new Map2To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1); + } + + static final CompactMapNode nodeOf2x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map2To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2); + } + + static final CompactMapNode nodeOf3x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + return new Map2To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map2To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map2To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6) { + return new Map2To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map2To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map2To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9) { + return new Map2To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf10x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + return new Map2To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf11x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11) { + return new Map2To11Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + static final CompactMapNode nodeOf12x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12) { + return new Map2To12Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + } + + static final CompactMapNode nodeOf13x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13) { + return new Map2To13Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + } + + static final CompactMapNode nodeOf14x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14) { + return new Map2To14Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13, node14); + } + + static final CompactMapNode nodeOf15x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, final CompactMapNode node15) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, node15, node14, node13, node12, node11, node10, + node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf16x2(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, final CompactMapNode node15, + final CompactMapNode node16) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, node16, node15, node14, node13, node12, node11, + node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3) { + return new Map3To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3); + } + + static final CompactMapNode nodeOf1x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1) { + return new Map3To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1); + } + + static final CompactMapNode nodeOf2x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2) { + return new Map3To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2); + } + + static final CompactMapNode nodeOf3x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map3To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map3To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + return new Map3To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map3To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map3To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8) { + return new Map3To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map3To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf10x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map3To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + static final CompactMapNode nodeOf11x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11) { + return new Map3To11Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + } + + static final CompactMapNode nodeOf12x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + return new Map3To12Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11, node12); + } + + static final CompactMapNode nodeOf13x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13) { + return new Map3To13Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11, node12, node13); + } + + static final CompactMapNode nodeOf14x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, final CompactMapNode node14) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, node14, node13, node12, node11, node10, + node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf15x3(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, final CompactMapNode node14, + final CompactMapNode node15) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, node15, node14, node13, node12, node11, + node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4) { + return new Map4To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4); + } + + static final CompactMapNode nodeOf1x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1) { + return new Map4To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1); + } + + static final CompactMapNode nodeOf2x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map4To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2); + } + + static final CompactMapNode nodeOf3x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map4To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + return new Map4To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map4To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map4To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + return new Map4To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + return new Map4To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, + node8); + } + + static final CompactMapNode nodeOf9x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + return new Map4To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + } + + static final CompactMapNode nodeOf10x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10) { + return new Map4To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + } + + static final CompactMapNode nodeOf11x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + return new Map4To11Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf12x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + return new Map4To12Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10, node11, node12); + } + + static final CompactMapNode nodeOf13x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, node13, node12, node11, + node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf14x4(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, node14, node13, node12, + node11, node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5) { + return new Map5To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5); + } + + static final CompactMapNode nodeOf1x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1) { + return new Map5To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1); + } + + static final CompactMapNode nodeOf2x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2) { + return new Map5To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2); + } + + static final CompactMapNode nodeOf3x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map5To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map5To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + return new Map5To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map5To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map5To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, + node7); + } + + static final CompactMapNode nodeOf8x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8) { + return new Map5To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, + node7, node8); + } + + static final CompactMapNode nodeOf9x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + return new Map5To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + } + + static final CompactMapNode nodeOf10x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + return new Map5To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf11x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11) { + return new Map5To11Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11); + } + + static final CompactMapNode nodeOf12x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, node12, node11, + node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf13x5(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, node13, node12, + node11, node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x6(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6) { + return new Map6To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6); + } + + static final CompactMapNode nodeOf1x6(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1) { + return new Map6To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1); + } + + static final CompactMapNode nodeOf2x6(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map6To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2); + } + + static final CompactMapNode nodeOf3x6(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map6To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x6(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + return new Map6To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x6(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map6To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, + node5); + } + + static final CompactMapNode nodeOf6x6(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map6To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, + node5, node6); + } + + static final CompactMapNode nodeOf7x6(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + return new Map6To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, + node5, node6, node7); + } + + static final CompactMapNode nodeOf8x6(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + return new Map6To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, + node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x6(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + return new Map6To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, + node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf10x6(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10) { + return new Map6To10Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10); + } + + static final CompactMapNode nodeOf11x6(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + node11, node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf12x6(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + node12, node11, node10, node9, node8, node7, node6, node5, node4, node3, node2, + node1}); + } + + static final CompactMapNode nodeOf0x7(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7) { + return new Map7To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7); + } + + static final CompactMapNode nodeOf1x7(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1) { + return new Map7To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1); + } + + static final CompactMapNode nodeOf2x7(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map7To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + } + + static final CompactMapNode nodeOf3x7(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + return new Map7To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3); + } + + static final CompactMapNode nodeOf4x7(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map7To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3, node4); + } + + static final CompactMapNode nodeOf5x7(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map7To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3, node4, node5); + } + + static final CompactMapNode nodeOf6x7(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6) { + return new Map7To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x7(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map7To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x7(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + return new Map7To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x7(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9) { + return new Map7To9Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, + node3, node4, node5, node6, node7, node8, node9); + } + + static final CompactMapNode nodeOf10x7(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, node10, node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf11x7(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, node11, node10, node9, node8, node7, node6, node5, node4, node3, node2, + node1}); + } + + static final CompactMapNode nodeOf0x8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8) { + return new Map8To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + } + + static final CompactMapNode nodeOf1x8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1) { + return new Map8To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, + node1); + } + + static final CompactMapNode nodeOf2x8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2) { + return new Map8To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2); + } + + static final CompactMapNode nodeOf3x8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map8To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2, node3); + } + + static final CompactMapNode nodeOf4x8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map8To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2, node3, node4); + } + + static final CompactMapNode nodeOf5x8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + return new Map8To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map8To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map8To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8) { + return new Map8To8Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, + node2, node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf9x8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, node9, node8, node7, node6, node5, node4, node3, node2, + node1}); + } + + static final CompactMapNode nodeOf10x8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, node10, node9, node8, node7, node6, node5, node4, node3, + node2, node1}); + } + + static final CompactMapNode nodeOf0x9(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9) { + return new Map9To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9); + } + + static final CompactMapNode nodeOf1x9(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, + final CompactMapNode node1) { + return new Map9To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1); + } + + static final CompactMapNode nodeOf2x9(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map9To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1, node2); + } + + static final CompactMapNode nodeOf3x9(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map9To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x9(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + return new Map9To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x9(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map9To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x9(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map9To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x9(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + return new Map9To7Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf8x9(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, node8, node7, node6, node5, node4, node3, node2, + node1}); + } + + static final CompactMapNode nodeOf9x9(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, node9, node8, node7, node6, node5, node4, node3, + node2, node1}); + } + + static final CompactMapNode nodeOf0x10(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10) { + return new Map10To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10); + } + + static final CompactMapNode nodeOf1x10(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1) { + return new Map10To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, node1); + } + + static final CompactMapNode nodeOf2x10(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1, final CompactMapNode node2) { + return new Map10To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, node1, node2); + } + + static final CompactMapNode nodeOf3x10(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map10To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x10(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map10To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x10(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + return new Map10To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x10(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map10To6Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf7x10(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, node7, node6, node5, node4, node3, + node2, node1}); + } + + static final CompactMapNode nodeOf8x10(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, node8, node7, node6, node5, node4, + node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x11(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11) { + return new Map11To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11); + } + + static final CompactMapNode nodeOf1x11(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final CompactMapNode node1) { + return new Map11To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, node1); + } + + static final CompactMapNode nodeOf2x11(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map11To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, node1, node2); + } + + static final CompactMapNode nodeOf3x11(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map11To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x11(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + return new Map11To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x11(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map11To5Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf6x11(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, node6, node5, node4, + node3, node2, node1}); + } + + static final CompactMapNode nodeOf7x11(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, node7, node6, node5, + node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x12(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12) { + return new Map12To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12); + } + + static final CompactMapNode nodeOf1x12(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final CompactMapNode node1) { + return new Map12To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, node1); + } + + static final CompactMapNode nodeOf2x12(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map12To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, node1, node2); + } + + static final CompactMapNode nodeOf3x12(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + return new Map12To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x12(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map12To4Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf5x12(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, node5, + node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf6x12(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, node6, + node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x13(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13) { + return new Map13To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13); + } + + static final CompactMapNode nodeOf1x13(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final CompactMapNode node1) { + return new Map13To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, node1); + } + + static final CompactMapNode nodeOf2x13(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final CompactMapNode node1, final CompactMapNode node2) { + return new Map13To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, node1, node2); + } + + static final CompactMapNode nodeOf3x13(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map13To3Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + } + + static final CompactMapNode nodeOf4x13(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf5x13(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x14(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14) { + return new Map14To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, key14, val14); + } + + static final CompactMapNode nodeOf1x14(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, + final CompactMapNode node1) { + return new Map14To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + } + + static final CompactMapNode nodeOf2x14(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map14To2Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + } + + static final CompactMapNode nodeOf3x14(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, node3, node2, node1}); + } + + static final CompactMapNode nodeOf4x14(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x15(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15) { + return new Map15To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + } + + static final CompactMapNode nodeOf1x15(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final CompactMapNode node1) { + return new Map15To1Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, + node1); + } + + static final CompactMapNode nodeOf2x15(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final CompactMapNode node1, final CompactMapNode node2) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, node2, node1}); + } + + static final CompactMapNode nodeOf3x15(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, node3, node2, node1}); + } + + static final CompactMapNode nodeOf0x16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final int key16, final int val16) { + return new Map16To0Node_5Bits_Spec0To16_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, + val9, key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, + key16, val16); + } + + static final CompactMapNode nodeOf1x16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final int key16, final int val16, final CompactMapNode node1) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, node1}); + } + + static final CompactMapNode nodeOf2x16(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final int key16, final int val16, final CompactMapNode node1, + final CompactMapNode node2) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, node2, node1}); + } + + static final CompactMapNode nodeOf0x17(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final int key16, final int val16, final int key17, final int val17) { + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, key17, val17}); + } + + static final CompactMapNode nodeOf1x17(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final int key16, final int val16, final int key17, final int val17, + final CompactMapNode node1) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, key17, val17, node1}); + } + + static final CompactMapNode nodeOf0x18(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9, final int key10, + final int val10, final int key11, final int val11, final int key12, final int val12, + final int key13, final int val13, final int key14, final int val14, final int key15, + final int val15, final int key16, final int val16, final int key17, final int val17, + final int key18, final int val18) { + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, + key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, key12, val12, key13, + val13, key14, val14, key15, val15, key16, val16, key17, val17, key18, val18}); + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + CompactMapNode nodeAt(final int bitpos) { + return getNode(nodeIndex(bitpos)); + } + + boolean containsKey(final int key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index) == key; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + bitPartitionSize()); + } + + return false; + } + + boolean containsKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index) == key; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + bitPartitionSize(), cmp); + } + + return false; + } + + Optional findByKey(final int key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index) == key) { + final java.lang.Integer result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + bitPartitionSize()); + } + + return Optional.empty(); + } + + Optional findByKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index) == key) { + final java.lang.Integer result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + bitPartitionSize(), cmp); + } + + return Optional.empty(); + } + + CompactMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + final int currentVal = getValue(dataIndex); + + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } else { + final int currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey), key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + bitPartitionSize(), details); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + CompactMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + final int currentVal = getValue(dataIndex); + + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } else { + final int currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey), key, val, keyHash, shift + bitPartitionSize()); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + bitPartitionSize(), details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + CompactMapNode removed(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex) == key) { + final int currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(1), getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(0), getValue(0)); + } + } else if (this.arity() == 17) { + return removeInplaceValueAndConvertToSpecializedNode(mutator, bitpos); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + bitPartitionSize(), details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + details.modified(); + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + CompactMapNode removed(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final MapResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex) == key) { + final int currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(1), getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(0), getValue(0)); + } + } else if (this.arity() == 17) { + return removeInplaceValueAndConvertToSpecializedNode(mutator, bitpos); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + bitPartitionSize(), details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + details.modified(); + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = (int) (map >> 1); + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getKey(i)), + Objects.hashCode(getValue(i)))); + + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedMapNode extends CompactMapNode { + + private final int nodeMap; + private final int dataMap; + + CompactMixedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + protected static abstract class CompactNodesOnlyMapNode extends CompactMapNode { + + private final int nodeMap; + + CompactNodesOnlyMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return 0; + } + + } + + protected static abstract class CompactValuesOnlyMapNode extends CompactMapNode { + + private final int dataMap; + + CompactValuesOnlyMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return 0; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + protected static abstract class CompactEmptyMapNode extends CompactMapNode { + + CompactEmptyMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) {} + + @Override + public int nodeMap() { + return 0; + } + + @Override + public int dataMap() { + return 0; + } + + } + + static final class FeatureFlags { + public static final long SUPPORTS_NOTHING = 0; + public static final long SUPPORTS_NODES = 1 << 0; + public static final long SUPPORTS_PAYLOAD = 1 << 1; + } + + private static final class BitmapIndexedMapNode extends CompactMixedMapNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + super(mutator, nodeMap, dataMap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + + assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < TUPLE_LENGTH * payloadArity(); i++) { + assert ((nodes[i] instanceof CompactMapNode) == false); + } + for (int i = TUPLE_LENGTH * payloadArity(); i < nodes.length; i++) { + assert ((nodes[i] instanceof CompactMapNode) == true); + } + } + + assert arity() > 16; + assert nodeInvariant(); + } + + @Override + int getKey(final int index) { + return (int) nodes[TUPLE_LENGTH * index]; + } + + @Override + int getValue(final int index) { + return (int) nodes[TUPLE_LENGTH * index + 1]; + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + return entryOf((int) nodes[TUPLE_LENGTH * index], (int) nodes[TUPLE_LENGTH * index + 1]); + } + + @SuppressWarnings("unchecked") + @Override + CompactMapNode getNode(final int index) { + return (CompactMapNode) nodes[nodes.length - 1 - index]; + } + + @SuppressWarnings("unchecked") + @Override + Iterator nodeIterator() { + final int length = nodeArity(); + final int offset = nodes.length - length; + + if (DEBUG) { + for (int i = offset; i < offset + length; i++) { + assert ((nodes[i] instanceof AbstractMapNode) == true); + } + } + + return (Iterator) ArrayIterator.of(nodes, offset, length); + } + + @Override + boolean hasPayload() { + return dataMap() != 0; + } + + @Override + int payloadArity() { + return java.lang.Integer.bitCount(dataMap()); + } + + @Override + boolean hasNodes() { + return nodeMap() != 0; + } + + @Override + int nodeArity() { + return java.lang.Integer.bitCount(nodeMap()); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos) + 1; + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = val; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(bitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = val; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + return nodeOf(mutator, nodeMap(), (int) (dataMap() | bitpos), dst); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + return nodeOf(mutator, nodeMap(), (int) (dataMap() ^ bitpos), dst); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2 + 1]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 2, dst, idxNew + 1, src.length - idxNew - 2); + + return nodeOf(mutator, (int) (nodeMap() | bitpos), (int) (dataMap() ^ bitpos), dst); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 2]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = node.getKey(0); + dst[idxNew + 1] = node.getValue(0); + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 2, src.length - idxOld - 1); + + return nodeOf(mutator, (int) (nodeMap() ^ bitpos), (int) (dataMap() | bitpos), dst); + } + + @Override + CompactMapNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (payloadArity()) { // 0 <= payloadArity <= 17 // or ts.nMax + case 1: { + + switch (valIndex) { + case 0: { + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + final CompactMapNode node11 = getNode(10); + final CompactMapNode node12 = getNode(11); + final CompactMapNode node13 = getNode(12); + final CompactMapNode node14 = getNode(13); + final CompactMapNode node15 = getNode(14); + final CompactMapNode node16 = getNode(15); + + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + + } + case 2: { + int key1; + int val1; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + final CompactMapNode node11 = getNode(10); + final CompactMapNode node12 = getNode(11); + final CompactMapNode node13 = getNode(12); + final CompactMapNode node14 = getNode(13); + final CompactMapNode node15 = getNode(14); + + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + + } + case 3: { + int key1; + int val1; + int key2; + int val2; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + final CompactMapNode node11 = getNode(10); + final CompactMapNode node12 = getNode(11); + final CompactMapNode node13 = getNode(12); + final CompactMapNode node14 = getNode(13); + + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + + } + case 4: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + final CompactMapNode node11 = getNode(10); + final CompactMapNode node12 = getNode(11); + final CompactMapNode node13 = getNode(12); + + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + + } + case 5: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + final CompactMapNode node11 = getNode(10); + final CompactMapNode node12 = getNode(11); + + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + + } + case 6: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + final CompactMapNode node11 = getNode(10); + + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + + } + case 7: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + final CompactMapNode node10 = getNode(9); + + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + + } + case 8: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + int key7; + int val7; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + final CompactMapNode node9 = getNode(8); + + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + + } + case 9: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + int key7; + int val7; + int key8; + int val8; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7, node8); + + } + case 10: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + int key7; + int val7; + int key8; + int val8; + int key9; + int val9; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + + } + case 11: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + int key7; + int val7; + int key8; + int val8; + int key9; + int val9; + int key10; + int val10; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + + } + case 12: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + int key7; + int val7; + int key8; + int val8; + int key9; + int val9; + int key10; + int val10; + int key11; + int val11; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(11); + val11 = getValue(11); + break; + } + case 11: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + + } + case 13: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + int key7; + int val7; + int key8; + int val8; + int key9; + int val9; + int key10; + int val10; + int key11; + int val11; + int key12; + int val12; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 11: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(12); + val12 = getValue(12); + break; + } + case 12: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + + } + case 14: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + int key7; + int val7; + int key8; + int val8; + int key9; + int val9; + int key10; + int val10; + int key11; + int val11; + int key12; + int val12; + int key13; + int val13; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 11: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 12: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(13); + val13 = getValue(13); + break; + } + case 13: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + + } + case 15: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + int key7; + int val7; + int key8; + int val8; + int key9; + int val9; + int key10; + int val10; + int key11; + int val11; + int key12; + int val12; + int key13; + int val13; + int key14; + int val14; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 11: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 12: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 13: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(14); + val14 = getValue(14); + break; + } + case 14: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(13); + val14 = getValue(13); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + + } + case 16: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + int key7; + int val7; + int key8; + int val8; + int key9; + int val9; + int key10; + int val10; + int key11; + int val11; + int key12; + int val12; + int key13; + int val13; + int key14; + int val14; + int key15; + int val15; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 11: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 12: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 13: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 14: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(13); + val14 = getValue(13); + key15 = getKey(15); + val15 = getValue(15); + break; + } + case 15: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(13); + val14 = getValue(13); + key15 = getKey(14); + val15 = getValue(14); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + + } + case 17: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + int key7; + int val7; + int key8; + int val8; + int key9; + int val9; + int key10; + int val10; + int key11; + int val11; + int key12; + int val12; + int key13; + int val13; + int key14; + int val14; + int key15; + int val15; + int key16; + int val16; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(9); + val9 = getValue(9); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 9: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(10); + val10 = getValue(10); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 10: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(11); + val11 = getValue(11); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 11: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(12); + val12 = getValue(12); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 12: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(13); + val13 = getValue(13); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 13: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(14); + val14 = getValue(14); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 14: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(13); + val14 = getValue(13); + key15 = getKey(15); + val15 = getValue(15); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 15: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(13); + val14 = getValue(13); + key15 = getKey(14); + val15 = getValue(14); + key16 = getKey(16); + val16 = getValue(16); + break; + } + case 16: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + key9 = getKey(8); + val9 = getValue(8); + key10 = getKey(9); + val10 = getValue(9); + key11 = getKey(10); + val11 = getValue(10); + key12 = getKey(11); + val12 = getValue(11); + key13 = getKey(12); + val13 = getValue(12); + key14 = getKey(13); + val14 = getValue(13); + key15 = getKey(14); + val15 = getValue(14); + key16 = getKey(15); + val16 = getValue(15); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + + } + default: + throw new IllegalStateException("Index out of range."); + } + } + } + + private static final class HashCollisionMapNode_5Bits_Spec0To16_IntKey_IntValue + extends CompactMapNode { + private final int[] keys; + private final int[] vals; + private final int hash; + + HashCollisionMapNode_5Bits_Spec0To16_IntKey_IntValue(final int hash, final int[] keys, + final int[] vals) { + this.keys = keys; + this.vals = vals; + this.hash = hash; + + assert payloadArity() >= 2; + } + + boolean containsKey(final int key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (int k : keys) { + if (k == key) { + return true; + } + } + } + return false; + } + + boolean containsKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (int k : keys) { + if (k == key) { + return true; + } + } + } + return false; + } + + Optional findByKey(final int key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final int _key = keys[i]; + if (key == _key) { + final int val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + Optional findByKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final int _key = keys[i]; + if (key == _key) { + final int val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + CompactMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx] == key) { + final int currentVal = vals[idx]; + + if (currentVal == val) { + return this; + } else { + // add new mapping + final int[] src = this.vals; + final int[] dst = new int[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode_5Bits_Spec0To16_IntKey_IntValue(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + final int[] keysNew = new int[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final int[] valsNew = new int[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits_Spec0To16_IntKey_IntValue(keyHash, keysNew, valsNew); + } + + CompactMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx] == key) { + final int currentVal = vals[idx]; + + if (currentVal == val) { + return this; + } else { + // add new mapping + final int[] src = this.vals; + final int[] dst = new int[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode_5Bits_Spec0To16_IntKey_IntValue(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + final int[] keysNew = new int[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final int[] valsNew = new int[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits_Spec0To16_IntKey_IntValue(keyHash, keysNew, valsNew); + } + + CompactMapNode removed(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final MapResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx] == key) { + final int currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final int theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final int theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details); + } else { + final int[] keysNew = new int[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final int[] valsNew = new int[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits_Spec0To16_IntKey_IntValue(keyHash, keysNew, + valsNew); + } + } + } + return this; + } + + CompactMapNode removed(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final MapResult details, final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx] == key) { + final int currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final int theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final int theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details, cmp); + } else { + final int[] keysNew = new int[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final int[] valsNew = new int[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits_Spec0To16_IntKey_IntValue(keyHash, keysNew, + valsNew); + } + } + } + return this; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return keys.length; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + int arity() { + return payloadArity(); + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + int getKey(final int index) { + return keys[index]; + } + + @Override + int getValue(final int index) { + return vals[index]; + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + return entryOf(keys[index], vals[index]); + } + + @Override + public CompactMapNode getNode(int index) { + throw new IllegalStateException("Is leaf node."); + } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + int nodeMap() { + throw new UnsupportedOperationException(); + } + + @Override + int dataMap() { + throw new UnsupportedOperationException(); + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractMapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractMapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + @SuppressWarnings("unchecked") + AbstractMapNode[] nodes = new AbstractMapNode[MAX_DEPTH]; + + AbstractMapIterator(AbstractMapNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractMapNode nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class MapKeyIterator extends AbstractMapIterator + implements Iterator { + + MapKeyIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public java.lang.Integer next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + protected static class MapValueIterator extends AbstractMapIterator + implements Iterator { + + MapValueIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public java.lang.Integer next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getValue(currentValueCursor++); + } + } + + } + + protected static class MapEntryIterator extends AbstractMapIterator + implements Iterator> { + + MapEntryIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public java.util.Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKeyValueEntry(currentValueCursor++); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieMap_5Bits_Spec0To16_IntKey_IntValueNodeIterator + implements Iterator { + + final Deque> nodeIteratorStack; + + TrieMap_5Bits_Spec0To16_IntKey_IntValueNodeIterator(AbstractMapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractMapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue + implements Map.Transient { + final private AtomicReference mutator; + private AbstractMapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue( + TrieMap_5Bits_Spec0To16_IntKey_IntValue trieMap_5Bits_Spec0To16_IntKey_IntValue) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieMap_5Bits_Spec0To16_IntKey_IntValue.rootNode; + this.hashCode = trieMap_5Bits_Spec0To16_IntKey_IntValue.hashCode; + this.cachedSize = trieMap_5Bits_Spec0To16_IntKey_IntValue.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = + entryIterator(); it.hasNext();) { + final java.util.Map.Entry entry = it.next(); + final int key = entry.getKey(); + final int val = entry.getValue(); + + hash += (int) key ^ (int) val; + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public java.lang.Integer put(final java.lang.Integer key, final java.lang.Integer val) { + throw new UnsupportedOperationException(); + } + + public void putAll(final java.util.Map m) { + throw new UnsupportedOperationException(); + } + + public void clear() { + throw new UnsupportedOperationException(); + } + + public java.lang.Integer remove(final Object key) { + throw new UnsupportedOperationException(); + } + + public boolean containsKey(final Object o) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + return rootNode.containsKey(key, transformHashCode(key), 0); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + return rootNode.containsKey(key, transformHashCode(key), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + public java.lang.Integer get(final Object o) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public java.lang.Integer getEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public java.lang.Integer __put(final java.lang.Integer key, final java.lang.Integer val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int old = details.getReplacedValue(); + + final int valHashOld = (int) old; + final int valHashNew = (int) val; + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } else { + final int valHashNew = (int) val; + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + public java.lang.Integer __putEquivalent(final java.lang.Integer key, + final java.lang.Integer val, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int old = details.getReplacedValue(); + + final int valHashOld = (int) old; + final int valHashNew = (int) val; + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } else { + final int valHashNew = (int) val; + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + public boolean __putAll( + final java.util.Map map) { + boolean modified = false; + + for (java.util.Map.Entry entry : map + .entrySet()) { + final boolean isPresent = this.containsKey(entry.getKey()); + final java.lang.Integer replaced = this.__put(entry.getKey(), entry.getValue()); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + public boolean __putAllEquivalent( + final java.util.Map map, + final Comparator cmp) { + boolean modified = false; + + for (java.util.Map.Entry entry : map + .entrySet()) { + final boolean isPresent = this.containsKeyEquivalent(entry.getKey(), cmp); + final java.lang.Integer replaced = + this.__putEquivalent(entry.getKey(), entry.getValue(), cmp); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + public java.lang.Integer __remove(final java.lang.Integer key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = (int) details.getReplacedValue(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + public java.lang.Integer __removeEquivalent(final java.lang.Integer key, + final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = (int) details.getReplacedValue(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + public int size() { + return cachedSize; + } + + public boolean isEmpty() { + return cachedSize == 0; + } + + public Iterator keyIterator() { + return new TransientMapKeyIterator(this); + } + + public Iterator valueIterator() { + return new TransientMapValueIterator(this); + } + + public Iterator> entryIterator() { + return new TransientMapEntryIterator(this); + } + + public static class TransientMapKeyIterator extends MapKeyIterator { + final TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue collection; + int lastKey; + + public TransientMapKeyIterator( + final TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue collection) { + super(collection.rootNode); + this.collection = collection; + } + + public java.lang.Integer next() { + return lastKey = super.next(); + } + + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(lastKey); + } + } + + public static class TransientMapValueIterator extends MapValueIterator { + final TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue collection; + + public TransientMapValueIterator( + final TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue collection) { + super(collection.rootNode); + this.collection = collection; + } + + public java.lang.Integer next() { + return super.next(); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientMapEntryIterator extends MapEntryIterator { + final TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue collection; + + public TransientMapEntryIterator( + final TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue collection) { + super(collection.rootNode); + this.collection = collection; + } + + public java.util.Map.Entry next() { + return super.next(); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = + entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public java.util.Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits_Spec0To16_IntKey_IntValue.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) + return false; + + for (@SuppressWarnings("unchecked") + Iterator it = that.entrySet().iterator(); it.hasNext();) { + java.util.Map.Entry entry = it.next(); + + try { + @SuppressWarnings("unchecked") + final int key = (java.lang.Integer) entry.getKey(); + final Optional result = + rootNode.findByKey(key, transformHashCode(key), 0); + + if (!result.isPresent()) { + return false; + } else { + @SuppressWarnings("unchecked") + final int val = (java.lang.Integer) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public Map.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieMap_5Bits_Spec0To16_IntKey_IntValue(rootNode, hashCode, cachedSize); + } + } + + private static final class Map0To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactEmptyMapNode { + + private Map0To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap) { + super(mutator, nodeMap, dataMap); + } + + boolean hasSlots() { + return false; + } + + int slotArity() { + return 0; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_EMPTY; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x1(mutator, nodeMap, dataMap, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map0To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + + private Map0To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 1; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x0(mutator, nodeMap, dataMap, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x1(mutator, nodeMap, dataMap, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map0To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 2; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x0(mutator, nodeMap, dataMap, node, node2); + case 1: + return nodeOf2x0(mutator, nodeMap, dataMap, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map0To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 3; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x0(mutator, nodeMap, dataMap, node, node2, node3); + case 1: + return nodeOf3x0(mutator, nodeMap, dataMap, node1, node, node3); + case 2: + return nodeOf3x0(mutator, nodeMap, dataMap, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To4Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map0To4Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 4; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x0(mutator, nodeMap, dataMap, node, node2, node3, node4); + case 1: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node, node3, node4); + case 2: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node2, node, node4); + case 3: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To5Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map0To5Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 5; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5); + case 1: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5); + case 2: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5); + case 3: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5); + case 4: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To6Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map0To6Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 6; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To7Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map0To7Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 7; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7); + case 2: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7); + case 3: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7); + case 4: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7); + case 5: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7); + case 6: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To8Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map0To8Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 8; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8); + case 3: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8); + case 4: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8); + case 5: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8); + case 6: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8); + case 7: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To9Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map0To9Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 9; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9); + case 4: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9); + case 5: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9); + case 6: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9); + case 7: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9); + case 8: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To10Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map0To10Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 10; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + case 1: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10); + case 2: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10); + case 3: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10); + case 4: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10); + case 5: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10); + case 6: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10); + case 7: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10); + case 8: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10); + case 9: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To11Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + + private Map0To11Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 11; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node11; + case 1: + return node10; + case 2: + return node9; + case 3: + return node8; + case 4: + return node7; + case 5: + return node6; + case 6: + return node5; + case 7: + return node4; + case 8: + return node3; + case 9: + return node2; + case 10: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 11; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf11x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11); + case 1: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10, node11); + case 2: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10, node11); + case 3: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10, node11); + case 4: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10, node11); + case 5: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10, node11); + case 6: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10, node11); + case 7: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10, node11); + case 8: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10, node11); + case 9: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node11); + case 10: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To12Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + + private Map0To12Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node12; + case 1: + return node11; + case 2: + return node10; + case 3: + return node9; + case 4: + return node8; + case 5: + return node7; + case 6: + return node6; + case 7: + return node5; + case 8: + return node4; + case 9: + return node3; + case 10: + return node2; + case 11: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 12; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf12x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10, node11, node12); + case 7: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10, node11, node12); + case 8: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10, node11, node12); + case 9: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node11, node12); + case 10: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node12); + case 11: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To13Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + + private Map0To13Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node13; + case 1: + return node12; + case 2: + return node11; + case 3: + return node10; + case 4: + return node9; + case 5: + return node8; + case 6: + return node7; + case 7: + return node6; + case 8: + return node5; + case 9: + return node4; + case 10: + return node3; + case 11: + return node2; + case 12: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 13; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf13x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13); + case 3: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10, node11, node12, node13); + case 4: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10, node11, node12, node13); + case 5: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10, node11, node12, node13); + case 6: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10, node11, node12, node13); + case 7: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10, node11, node12, node13); + case 8: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10, node11, node12, node13); + case 9: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node11, node12, node13); + case 10: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node12, node13); + case 11: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node13); + case 12: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To14Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + private final CompactMapNode node14; + + private Map0To14Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + this.node14 = node14; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node14; + case 1: + return node13; + case 2: + return node12; + case 3: + return node11; + case 4: + return node10; + case 5: + return node9; + case 6: + return node8; + case 7: + return node7; + case 8: + return node6; + case 9: + return node5; + case 10: + return node4; + case 11: + return node3; + case 12: + return node2; + case 13: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13, node14); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 14; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf14x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14); + case 2: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14); + case 3: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14); + case 4: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10, node11, node12, node13, node14); + case 5: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10, node11, node12, node13, node14); + case 6: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10, node11, node12, node13, node14); + case 7: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10, node11, node12, node13, node14); + case 8: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10, node11, node12, node13, node14); + case 9: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node11, node12, node13, node14); + case 10: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node12, node13, node14); + case 11: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node13, node14); + case 12: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node, node14); + case 13: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To15Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + private final CompactMapNode node14; + private final CompactMapNode node15; + + private Map0To15Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + this.node14 = node14; + this.node15 = node15; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node15; + case 1: + return node14; + case 2: + return node13; + case 3: + return node12; + case 4: + return node11; + case 5: + return node10; + case 6: + return node9; + case 7: + return node8; + case 8: + return node7; + case 9: + return node6; + case 10: + return node5; + case 11: + return node4; + case 12: + return node3; + case 13: + return node2; + case 14: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13, node14, node15); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 15; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf15x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 1: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 2: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 3: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 4: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 5: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 6: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10, node11, node12, node13, node14, node15); + case 7: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10, node11, node12, node13, node14, node15); + case 8: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10, node11, node12, node13, node14, node15); + case 9: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node11, node12, node13, node14, node15); + case 10: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node12, node13, node14, node15); + case 11: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node13, node14, node15); + case 12: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node, node14, node15); + case 13: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node, node15); + case 14: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 14: + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map0To16Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + private final CompactMapNode node14; + private final CompactMapNode node15; + private final CompactMapNode node16; + + private Map0To16Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13, + final CompactMapNode node14, final CompactMapNode node15, final CompactMapNode node16) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + this.node14 = node14; + this.node15 = node15; + this.node16 = node16; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + throw new IllegalStateException("Index out of range."); + } + + int getValue(final int index) { + throw new IllegalStateException("Index out of range."); + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node16; + case 1: + return node15; + case 2: + return node14; + case 3: + return node13; + case 4: + return node12; + case 5: + return node11; + case 6: + return node10; + case 7: + return node9; + case 8: + return node8; + case 9: + return node7; + case 10: + return node6; + case 11: + return node5; + case 12: + return node4; + case 13: + return node3; + case 14: + return node2; + case 15: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13, node14, node15, node16); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 16; + } + + boolean hasPayload() { + return false; + } + + int payloadArity() { + return 0; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf16x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf16x0(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 1: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 2: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 3: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 4: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 5: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 6: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node8, node9, node10, node11, node12, node13, node14, node15, node16); + case 7: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node9, node10, node11, node12, node13, node14, node15, node16); + case 8: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node10, node11, node12, node13, node14, node15, node16); + case 9: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node11, node12, node13, node14, node15, node16); + case 10: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node12, node13, node14, node15, node16); + case 11: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node13, node14, node15, node16); + case 12: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node, node14, node15, node16); + case 13: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node, node15, node16); + case 14: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node, node16); + case 15: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node7, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node8, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node9, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node10, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node11, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node12, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node13, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node14, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node15, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 14: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node16); + default: + throw new IllegalStateException("Index out of range."); + } + case 15: + switch (valIndex) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + + private Map1To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 2; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x1(mutator, nodeMap, dataMap, key1, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x2(mutator, nodeMap, dataMap, key, val, key1, val1); + case 1: + return nodeOf0x2(mutator, nodeMap, dataMap, key1, val1, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x0(mutator, nodeMap, dataMap); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x0(mutator, nodeMap, dataMap, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map1To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + + private Map1To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 3; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key1, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1); + case 1: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x0(mutator, nodeMap, dataMap, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key1, val1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x0(mutator, nodeMap, dataMap, node, node1); + case 1: + return nodeOf2x0(mutator, nodeMap, dataMap, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x2(mutator, nodeMap, dataMap, key, val, key1, val1); + case 1: + return nodeOf0x2(mutator, nodeMap, dataMap, key1, val1, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map1To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 4; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key1, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x0(mutator, nodeMap, dataMap, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key1, val1, node, node2); + case 1: + return nodeOf2x1(mutator, nodeMap, dataMap, key1, val1, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x0(mutator, nodeMap, dataMap, node, node1, node2); + case 1: + return nodeOf3x0(mutator, nodeMap, dataMap, node1, node, node2); + case 2: + return nodeOf3x0(mutator, nodeMap, dataMap, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2); + case 1: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1); + case 1: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map1To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 5; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x0(mutator, nodeMap, dataMap, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3); + case 1: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3); + case 2: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x0(mutator, nodeMap, dataMap, node, node1, node2, node3); + case 1: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node, node2, node3); + case 2: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node2, node, node3); + case 3: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To4Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map1To4Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 6; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x0(mutator, nodeMap, dataMap, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4); + case 1: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4); + case 2: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4); + case 3: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4); + case 1: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4); + case 2: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4); + case 3: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4); + case 4: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, + node4); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, + node4); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node4); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To5Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map1To5Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 7; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5); + case 1: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5); + case 2: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5); + case 3: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5); + case 4: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To6Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map1To6Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 8; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6); + case 1: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6); + case 2: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6); + case 3: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6); + case 4: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6); + case 5: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To7Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map1To7Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 9; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7); + case 2: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7); + case 3: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7); + case 4: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7); + case 5: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node, node7); + case 6: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7); + case 7: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6, node7); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6, node7); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6, node7); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6, node7); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6, node7); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node7); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To8Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map1To8Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 10; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8); + case 3: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8); + case 4: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8); + case 5: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node, node7, node8); + case 6: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node, node8); + case 7: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8); + case 7: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8); + case 8: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6, node7, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6, node7, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6, node7, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6, node7, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6, node7, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node7, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node8); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To9Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map1To9Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 11; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9); + case 4: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9); + case 5: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node, node7, node8, node9); + case 6: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node, node8, node9); + case 7: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7, node, node9); + case 8: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9); + case 4: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9); + case 5: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9); + case 6: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9); + case 7: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9); + case 8: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9); + case 9: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6, node7, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6, node7, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6, node7, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6, node7, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6, node7, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node7, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node8, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node9); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To10Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map1To10Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf10x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10); + case 1: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9, node10); + case 2: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9, node10); + case 3: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9, node10); + case 4: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9, node10); + case 5: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node7, node8, node9, node10); + case 6: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node8, node9, node10); + case 7: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node9, node10); + case 8: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node10); + case 9: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf11x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10); + case 1: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10); + case 2: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9, node10); + case 3: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9, node10); + case 4: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9, node10); + case 5: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9, node10); + case 6: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9, node10); + case 7: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9, node10); + case 8: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9, node10); + case 9: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node10); + case 10: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node7, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node8, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node9, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node10); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To11Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + + private Map1To11Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node11; + case 1: + return node10; + case 2: + return node9; + case 3: + return node8; + case 4: + return node7; + case 5: + return node6; + case 6: + return node5; + case 7: + return node4; + case 8: + return node3; + case 9: + return node2; + case 10: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 11; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf11x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node7, node8, node9, node10, node11); + case 6: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node8, node9, node10, node11); + case 7: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node9, node10, node11); + case 8: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node10, node11); + case 9: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node11); + case 10: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf12x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9, node10, node11); + case 6: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9, node10, node11); + case 7: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9, node10, node11); + case 8: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9, node10, node11); + case 9: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node10, node11); + case 10: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node11); + case 11: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To12Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + + private Map1To12Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node12; + case 1: + return node11; + case 2: + return node10; + case 3: + return node9; + case 4: + return node8; + case 5: + return node7; + case 6: + return node6; + case 7: + return node5; + case 8: + return node4; + case 9: + return node3; + case 10: + return node2; + case 11: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 12; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf12x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node8, node9, node10, node11, node12); + case 7: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node9, node10, node11, node12); + case 8: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node10, node11, node12); + case 9: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node11, node12); + case 10: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node12); + case 11: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf13x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9, node10, node11, node12); + case 7: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9, node10, node11, node12); + case 8: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9, node10, node11, node12); + case 9: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node10, node11, node12); + case 10: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node11, node12); + case 11: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node12); + case 12: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To13Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + + private Map1To13Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node13; + case 1: + return node12; + case 2: + return node11; + case 3: + return node10; + case 4: + return node9; + case 5: + return node8; + case 6: + return node7; + case 7: + return node6; + case 8: + return node5; + case 9: + return node4; + case 10: + return node3; + case 11: + return node2; + case 12: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 13; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf13x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 3: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 4: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9, node10, node11, node12, node13); + case 5: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node7, node8, node9, node10, node11, node12, node13); + case 6: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node8, node9, node10, node11, node12, node13); + case 7: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node9, node10, node11, node12, node13); + case 8: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node10, node11, node12, node13); + case 9: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node11, node12, node13); + case 10: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node12, node13); + case 11: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node13); + case 12: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf14x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 3: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 4: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9, node10, node11, node12, node13); + case 5: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9, node10, node11, node12, node13); + case 6: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9, node10, node11, node12, node13); + case 7: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9, node10, node11, node12, node13); + case 8: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9, node10, node11, node12, node13); + case 9: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node10, node11, node12, node13); + case 10: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node11, node12, node13); + case 11: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node12, node13); + case 12: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node, node13); + case 13: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node13); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To14Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + private final CompactMapNode node14; + + private Map1To14Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + this.node14 = node14; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node14; + case 1: + return node13; + case 2: + return node12; + case 3: + return node11; + case 4: + return node10; + case 5: + return node9; + case 6: + return node8; + case 7: + return node7; + case 8: + return node6; + case 9: + return node5; + case 10: + return node4; + case 11: + return node3; + case 12: + return node2; + case 13: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13, node14); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 14; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf14x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 2: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 3: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 4: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 5: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node7, node8, node9, node10, node11, node12, node13, node14); + case 6: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node8, node9, node10, node11, node12, node13, node14); + case 7: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node9, node10, node11, node12, node13, node14); + case 8: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node10, node11, node12, node13, node14); + case 9: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node11, node12, node13, node14); + case 10: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node12, node13, node14); + case 11: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node13, node14); + case 12: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node, node14); + case 13: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf15x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 2: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 3: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 4: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 5: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 6: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9, node10, node11, node12, node13, node14); + case 7: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9, node10, node11, node12, node13, node14); + case 8: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9, node10, node11, node12, node13, node14); + case 9: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node10, node11, node12, node13, node14); + case 10: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node11, node12, node13, node14); + case 11: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node12, node13, node14); + case 12: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node, node13, node14); + case 13: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node, node14); + case 14: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node14); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map1To15Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + private final CompactMapNode node14; + private final CompactMapNode node15; + + private Map1To15Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12, + final CompactMapNode node13, final CompactMapNode node14, final CompactMapNode node15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + this.node14 = node14; + this.node15 = node15; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node15; + case 1: + return node14; + case 2: + return node13; + case 3: + return node12; + case 4: + return node11; + case 5: + return node10; + case 6: + return node9; + case 7: + return node8; + case 8: + return node7; + case 9: + return node6; + case 10: + return node5; + case 11: + return node4; + case 12: + return node3; + case 13: + return node2; + case 14: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13, node14, node15); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 15; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 1; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf15x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf15x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf15x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 1: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 2: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 3: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 4: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 5: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 6: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node8, node9, node10, node11, node12, node13, node14, node15); + case 7: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node9, node10, node11, node12, node13, node14, node15); + case 8: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node10, node11, node12, node13, node14, node15); + case 9: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node11, node12, node13, node14, node15); + case 10: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node12, node13, node14, node15); + case 11: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node13, node14, node15); + case 12: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node, node14, node15); + case 13: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node, node15); + case 14: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf16x0(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 1: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 2: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 3: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 4: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 5: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 6: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7, node8, node9, node10, node11, node12, node13, node14, node15); + case 7: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node, node8, node9, node10, node11, node12, node13, node14, node15); + case 8: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node, node9, node10, node11, node12, node13, node14, node15); + case 9: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node, node10, node11, node12, node13, node14, node15); + case 10: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node, node11, node12, node13, node14, node15); + case 11: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node, node12, node13, node14, node15); + case 12: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node, node13, node14, node15); + case 13: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node, node14, node15); + case 14: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node, node15); + case 15: + return nodeOf16x0(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10, node11, node12, node13, node14, node15, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node14, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node14, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node15); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node15); + default: + throw new IllegalStateException("Index out of range."); + } + case 14: + switch (valIndex) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + + private Map2To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 4; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x2(mutator, nodeMap, dataMap, key1, val, key2, val2); + case 1: + return nodeOf0x2(mutator, nodeMap, dataMap, key1, val1, key2, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2); + case 1: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2); + case 2: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x1(mutator, nodeMap, dataMap, key2, val2); + case 1: + return nodeOf0x1(mutator, nodeMap, dataMap, key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key2, val2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key1, val1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map2To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + + private Map2To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 5; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1); + case 1: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1); + case 1: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1); + case 2: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x1(mutator, nodeMap, dataMap, key2, val2, node1); + case 1: + return nodeOf1x1(mutator, nodeMap, dataMap, key1, val1, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key2, val2, node, node1); + case 1: + return nodeOf2x1(mutator, nodeMap, dataMap, key2, val2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key1, val1, node, node1); + case 1: + return nodeOf2x1(mutator, nodeMap, dataMap, key1, val1, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2); + case 1: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2); + case 2: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map2To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 6; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2); + case 2: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x1(mutator, nodeMap, dataMap, key2, val2, node1, node2); + case 1: + return nodeOf2x1(mutator, nodeMap, dataMap, key1, val1, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2); + case 1: + return nodeOf3x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2); + case 2: + return nodeOf3x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2); + case 1: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2); + case 2: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2); + case 1: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2); + case 2: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1); + case 1: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1); + case 2: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map2To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 7; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3); + case 1: + return nodeOf3x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3); + case 2: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3); + case 1: + return nodeOf4x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3); + case 2: + return nodeOf4x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3); + case 3: + return nodeOf4x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3); + case 1: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3); + case 2: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3); + case 3: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3); + case 2: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3); + case 2: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2); + case 2: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To4Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map2To4Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 8; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4); + case 1: + return nodeOf4x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4); + case 2: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4); + case 3: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To5Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map2To5Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 9; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5); + case 1: + return nodeOf5x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5); + case 2: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5); + case 3: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5); + case 4: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To6Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map2To6Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 10; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf6x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6); + case 2: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6); + case 3: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6); + case 4: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6); + case 5: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To7Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map2To7Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 11; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf7x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7); + case 2: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7); + case 3: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7); + case 4: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7); + case 5: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7); + case 6: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To8Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map2To8Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf8x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8); + case 3: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8); + case 4: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8); + case 5: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8); + case 6: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8); + case 7: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8); + case 3: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8); + case 4: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8); + case 5: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8); + case 6: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8); + case 7: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8); + case 8: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8); + case 3: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8); + case 4: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8); + case 5: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8); + case 6: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8); + case 7: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8); + case 8: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To9Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map2To9Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf9x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8, node9); + case 5: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8, node9); + case 6: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8, node9); + case 7: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node, node9); + case 8: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To10Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map2To10Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf10x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8, node9, node10); + case 5: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8, node9, node10); + case 6: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8, node9, node10); + case 7: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node, node9, node10); + case 8: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node, node10); + case 9: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To11Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + + private Map2To11Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node11; + case 1: + return node10; + case 2: + return node9; + case 3: + return node8; + case 4: + return node7; + case 5: + return node6; + case 6: + return node5; + case 7: + return node4; + case 8: + return node3; + case 9: + return node2; + case 10: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 11; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf11x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8, node9, node10, node11); + case 6: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8, node9, node10, node11); + case 7: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node, node9, node10, node11); + case 8: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node, node10, node11); + case 9: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node, node11); + case 10: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11); + case 6: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11); + case 7: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11); + case 8: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11); + case 9: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11); + case 10: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11); + case 11: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11); + case 6: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11); + case 7: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11); + case 8: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11); + case 9: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11); + case 10: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11); + case 11: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To12Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + + private Map2To12Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node12; + case 1: + return node11; + case 2: + return node10; + case 3: + return node9; + case 4: + return node8; + case 5: + return node7; + case 6: + return node6; + case 7: + return node5; + case 8: + return node4; + case 9: + return node3; + case 10: + return node2; + case 11: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 12; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf12x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8, node9, node10, node11, node12); + case 7: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node, node9, node10, node11, node12); + case 8: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node, node10, node11, node12); + case 9: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node, node11, node12); + case 10: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node, node12); + case 11: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11, node12); + case 7: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11, node12); + case 8: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11, node12); + case 9: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11, node12); + case 10: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11, node12); + case 11: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node12); + case 12: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11, node12); + case 7: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11, node12); + case 8: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11, node12); + case 9: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11, node12); + case 10: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11, node12); + case 11: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node12); + case 12: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To13Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + + private Map2To13Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node13; + case 1: + return node12; + case 2: + return node11; + case 3: + return node10; + case 4: + return node9; + case 5: + return node8; + case 6: + return node7; + case 7: + return node6; + case 8: + return node5; + case 9: + return node4; + case 10: + return node3; + case 11: + return node2; + case 12: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 13; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf13x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 3: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 4: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8, node9, node10, node11, node12, node13); + case 5: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8, node9, node10, node11, node12, node13); + case 6: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8, node9, node10, node11, node12, node13); + case 7: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node, node9, node10, node11, node12, node13); + case 8: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node, node10, node11, node12, node13); + case 9: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node, node11, node12, node13); + case 10: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node, node12, node13); + case 11: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node, node13); + case 12: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 3: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 4: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 5: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11, node12, node13); + case 6: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11, node12, node13); + case 7: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11, node12, node13); + case 8: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11, node12, node13); + case 9: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11, node12, node13); + case 10: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11, node12, node13); + case 11: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node12, node13); + case 12: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node, node13); + case 13: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 3: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 4: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 5: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11, node12, node13); + case 6: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11, node12, node13); + case 7: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11, node12, node13); + case 8: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11, node12, node13); + case 9: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11, node12, node13); + case 10: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11, node12, node13); + case 11: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node12, node13); + case 12: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node, node13); + case 13: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node13); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node13); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map2To14Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + private final CompactMapNode node14; + + private Map2To14Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11, + final CompactMapNode node12, final CompactMapNode node13, final CompactMapNode node14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + this.node14 = node14; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node14; + case 1: + return node13; + case 2: + return node12; + case 3: + return node11; + case 4: + return node10; + case 5: + return node9; + case 6: + return node8; + case 7: + return node7; + case 8: + return node6; + case 9: + return node5; + case 10: + return node4; + case 11: + return node3; + case 12: + return node2; + case 13: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13, node14); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 14; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 2; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf14x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13, node14); + case 1: + return nodeOf14x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13, node14); + case 2: + return nodeOf14x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf14x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf14x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 2: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 3: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 4: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 5: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node, node7, node8, node9, node10, node11, node12, node13, node14); + case 6: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node, node8, node9, node10, node11, node12, node13, node14); + case 7: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node, node9, node10, node11, node12, node13, node14); + case 8: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node, node10, node11, node12, node13, node14); + case 9: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node, node11, node12, node13, node14); + case 10: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node, node12, node13, node14); + case 11: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node, node13, node14); + case 12: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node, node14); + case 13: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 2: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 3: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 4: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 5: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 6: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11, node12, node13, node14); + case 7: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11, node12, node13, node14); + case 8: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11, node12, node13, node14); + case 9: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11, node12, node13, node14); + case 10: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11, node12, node13, node14); + case 11: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node12, node13, node14); + case 12: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node, node13, node14); + case 13: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node, node14); + case 14: + return nodeOf15x1(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 1: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 2: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 3: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 4: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 5: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6, node7, node8, node9, node10, node11, node12, node13, node14); + case 6: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node, node7, node8, node9, node10, node11, node12, node13, node14); + case 7: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node, node8, node9, node10, node11, node12, node13, node14); + case 8: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node, node9, node10, node11, node12, node13, node14); + case 9: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node, node10, node11, node12, node13, node14); + case 10: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node, node11, node12, node13, node14); + case 11: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node, node12, node13, node14); + case 12: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node, node13, node14); + case 13: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node, node14); + case 14: + return nodeOf15x1(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node7, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node8, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node9, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node10, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node11, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node12, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node13, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node14); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node14); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node14); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (valIndex) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + + private Map3To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 6; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3); + case 1: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3); + case 2: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3); + case 1: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3); + case 2: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3); + case 3: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x2(mutator, nodeMap, dataMap, key2, val2, key3, val3); + case 1: + return nodeOf0x2(mutator, nodeMap, dataMap, key1, val1, key3, val3); + case 2: + return nodeOf0x2(mutator, nodeMap, dataMap, key1, val1, key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map3To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + + private Map3To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 7; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1); + case 1: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1); + case 2: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1); + case 1: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1); + case 2: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1); + case 3: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1); + case 1: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1); + case 2: + return nodeOf1x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3); + case 1: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3); + case 2: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3); + case 3: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map3To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 8; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2); + case 2: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2); + case 2: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2); + case 3: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2); + case 1: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2); + case 2: + return nodeOf2x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2); + case 2: + return nodeOf3x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2); + case 2: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2); + case 2: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2); + case 1: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2); + case 2: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2); + case 3: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1); + case 1: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1); + case 2: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1); + case 3: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map3To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 9; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3); + case 1: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3); + case 2: + return nodeOf3x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3); + case 2: + return nodeOf4x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3); + case 3: + return nodeOf4x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3); + case 2: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3); + case 3: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3); + case 2: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3); + case 3: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3); + case 2: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3); + case 3: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3); + case 2: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3); + case 3: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2); + case 2: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2); + case 3: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To4Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map3To4Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 10; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4); + case 1: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4); + case 2: + return nodeOf4x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4); + case 3: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To5Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map3To5Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 11; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5); + case 1: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5); + case 2: + return nodeOf5x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5); + case 3: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5); + case 4: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To6Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map3To6Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6); + case 2: + return nodeOf6x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6); + case 3: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6); + case 4: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6); + case 5: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To7Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map3To7Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf7x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7); + case 3: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7); + case 4: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7); + case 5: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7); + case 6: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To8Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map3To8Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf8x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7, node8); + case 4: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7, node8); + case 5: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7, node8); + case 6: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node8); + case 7: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node8); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To9Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map3To9Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7, node8, node9); + case 5: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7, node8, node9); + case 6: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node8, node9); + case 7: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node, node9); + case 8: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To10Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map3To10Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf10x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7, node8, node9, node10); + case 5: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7, node8, node9, node10); + case 6: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node8, node9, node10); + case 7: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node, node9, node10); + case 8: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node, node10); + case 9: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To11Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + + private Map3To11Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node11; + case 1: + return node10; + case 2: + return node9; + case 3: + return node8; + case 4: + return node7; + case 5: + return node6; + case 6: + return node5; + case 7: + return node4; + case 8: + return node3; + case 9: + return node2; + case 10: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 11; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf11x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7, node8, node9, node10, node11); + case 6: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node8, node9, node10, node11); + case 7: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node, node9, node10, node11); + case 8: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node, node10, node11); + case 9: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node, node11); + case 10: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11); + case 6: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11); + case 7: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11); + case 8: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11); + case 9: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11); + case 10: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11); + case 11: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11); + case 6: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11); + case 7: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11); + case 8: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11); + case 9: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11); + case 10: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11); + case 11: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11); + case 6: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11); + case 7: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11); + case 8: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11); + case 9: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11); + case 10: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11); + case 11: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To12Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + + private Map3To12Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node12; + case 1: + return node11; + case 2: + return node10; + case 3: + return node9; + case 4: + return node8; + case 5: + return node7; + case 6: + return node6; + case 7: + return node5; + case 8: + return node4; + case 9: + return node3; + case 10: + return node2; + case 11: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 12; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf12x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node8, node9, node10, node11, node12); + case 7: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node, node9, node10, node11, node12); + case 8: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node, node10, node11, node12); + case 9: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node, node11, node12); + case 10: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node, node12); + case 11: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11, node12); + case 7: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11, node12); + case 8: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11, node12); + case 9: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11, node12); + case 10: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11, node12); + case 11: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node12); + case 12: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11, node12); + case 7: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11, node12); + case 8: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11, node12); + case 9: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11, node12); + case 10: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11, node12); + case 11: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node12); + case 12: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 4: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11, node12); + case 5: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11, node12); + case 6: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11, node12); + case 7: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11, node12); + case 8: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11, node12); + case 9: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11, node12); + case 10: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11, node12); + case 11: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node12); + case 12: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map3To13Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + private final CompactMapNode node13; + + private Map3To13Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10, + final CompactMapNode node11, final CompactMapNode node12, final CompactMapNode node13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + this.node13 = node13; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node13; + case 1: + return node12; + case 2: + return node11; + case 3: + return node10; + case 4: + return node9; + case 5: + return node8; + case 6: + return node7; + case 7: + return node6; + case 8: + return node5; + case 9: + return node4; + case 10: + return node3; + case 11: + return node2; + case 12: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12, node13); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 13; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 3; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf13x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf13x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf13x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 3: + return nodeOf13x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf13x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 1: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + case 2: + return nodeOf13x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6, node7, node8, node9, node10, node11, node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 3: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 4: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node6, node7, node8, node9, node10, node11, node12, + node13); + case 5: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node7, node8, node9, node10, node11, node12, + node13); + case 6: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node8, node9, node10, node11, node12, + node13); + case 7: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node, node9, node10, node11, node12, + node13); + case 8: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node, node10, node11, node12, + node13); + case 9: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node, node11, node12, node13); + case 10: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node, node12, node13); + case 11: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node13); + case 12: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 3: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 4: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 5: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11, node12, + node13); + case 6: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11, node12, + node13); + case 7: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11, node12, + node13); + case 8: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11, node12, + node13); + case 9: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11, node12, + node13); + case 10: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11, node12, + node13); + case 11: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node12, + node13); + case 12: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node, + node13); + case 13: + return nodeOf14x2(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 3: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 4: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 5: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11, node12, + node13); + case 6: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11, node12, + node13); + case 7: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11, node12, + node13); + case 8: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11, node12, + node13); + case 9: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11, node12, + node13); + case 10: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11, node12, + node13); + case 11: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node12, + node13); + case 12: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node, + node13); + case 13: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 1: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 2: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 3: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node, node4, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 4: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node, node5, node6, node7, node8, node9, node10, node11, node12, + node13); + case 5: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node, node6, node7, node8, node9, node10, node11, node12, + node13); + case 6: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node, node7, node8, node9, node10, node11, node12, + node13); + case 7: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node, node8, node9, node10, node11, node12, + node13); + case 8: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node, node9, node10, node11, node12, + node13); + case 9: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node, node10, node11, node12, + node13); + case 10: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node, node11, node12, + node13); + case 11: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node, node12, + node13); + case 12: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node, + node13); + case 13: + return nodeOf14x2(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node5, node6, node7, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node6, node7, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node7, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node8, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node9, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node10, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node11, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node12, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node13); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node13); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node13); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node13); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (valIndex) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + + private Map4To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 8; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4); + case 1: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4); + case 2: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4); + case 3: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4); + case 1: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4); + case 2: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4); + case 3: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4); + case 4: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4); + case 1: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4); + case 2: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4); + case 3: + return nodeOf0x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map4To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + + private Map4To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 9; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1); + case 1: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1); + case 2: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1); + case 3: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1); + case 1: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1); + case 2: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1); + case 3: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1); + case 4: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1); + case 1: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1); + case 2: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1); + case 3: + return nodeOf1x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4); + case 1: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4); + case 2: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4); + case 3: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4); + case 4: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map4To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 10; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2); + case 2: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2); + case 3: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2); + case 2: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2); + case 3: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2); + case 4: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2); + case 1: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2); + case 2: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2); + case 3: + return nodeOf2x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2); + case 1: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2); + case 2: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2); + case 3: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2); + case 4: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1); + case 1: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1); + case 2: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1); + case 3: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1); + case 4: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map4To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 11; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3); + case 1: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3); + case 2: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3); + case 3: + return nodeOf3x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3); + case 3: + return nodeOf4x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3); + case 3: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3); + case 3: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3); + case 3: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3); + case 2: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3); + case 3: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3); + case 4: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3); + case 2: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3); + case 3: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3); + case 4: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2); + case 2: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2); + case 3: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2); + case 4: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To4Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map4To4Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4); + case 1: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4); + case 2: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4); + case 3: + return nodeOf4x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3, node4); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3, node4); + case 3: + return nodeOf5x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node, node4); + case 4: + return nodeOf5x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3, node4); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3, node4); + case 3: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node, node4); + case 4: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3, node4); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3, node4); + case 3: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node, node4); + case 4: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3, node4); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3, node4); + case 3: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node4); + case 4: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To5Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map4To5Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4, node5); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4, node5); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5); + case 1: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5); + case 2: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5); + case 3: + return nodeOf5x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5); + case 3: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5); + case 4: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5); + case 5: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5); + case 3: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5); + case 4: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5); + case 5: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3, node4, node5); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3, node4, node5); + case 3: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node, node4, node5); + case 4: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node, node5); + case 5: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3, node4, node5); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3, node4, node5); + case 3: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node4, node5); + case 4: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node5); + case 5: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To6Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map4To6Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6); + case 2: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6); + case 3: + return nodeOf6x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To7Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map4To7Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6, node7); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6, node7); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6, node7); + case 5: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node7); + case 6: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6, node7); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6, node7); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6, node7); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6, node7); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node7); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To8Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map4To8Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6, node7, node8); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6, node7, node8); + case 5: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node7, node8); + case 6: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node8); + case 7: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6, node7, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6, node7, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6, node7, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node7, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node8); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To9Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map4To9Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6, node7, node8, node9); + case 5: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node7, node8, node9); + case 6: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node8, node9); + case 7: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node9); + case 8: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To10Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map4To10Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf10x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6, node7, node8, node9, node10); + case 5: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node7, node8, node9, node10); + case 6: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node8, node9, node10); + case 7: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node9, node10); + case 8: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node, node10); + case 9: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10); + case 5: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10); + case 6: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10); + case 7: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10); + case 8: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10); + case 9: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10); + case 10: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To11Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + + private Map4To11Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node11; + case 1: + return node10; + case 2: + return node9; + case 3: + return node8; + case 4: + return node7; + case 5: + return node6; + case 6: + return node5; + case 7: + return node4; + case 8: + return node3; + case 9: + return node2; + case 10: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 11; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf11x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6, node7, node8, node9, node10, node11); + case 5: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node7, node8, node9, node10, node11); + case 6: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node8, node9, node10, node11); + case 7: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node9, node10, node11); + case 8: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node, node10, node11); + case 9: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node11); + case 10: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map4To12Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + private final CompactMapNode node12; + + private Map4To12Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8, final CompactMapNode node9, + final CompactMapNode node10, final CompactMapNode node11, final CompactMapNode node12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + this.node12 = node12; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node12; + case 1: + return node11; + case 2: + return node10; + case 3: + return node9; + case 4: + return node8; + case 5: + return node7; + case 6: + return node6; + case 7: + return node5; + case 8: + return node4; + case 9: + return node3; + case 10: + return node2; + case 11: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 12; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 4; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf12x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf12x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf12x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf12x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf12x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf12x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 1: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 2: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + case 3: + return nodeOf12x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node5, node6, node7, node8, node9, node10, node11, + node12); + case 4: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node6, node7, node8, node9, node10, node11, + node12); + case 5: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node7, node8, node9, node10, node11, + node12); + case 6: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node8, node9, node10, node11, + node12); + case 7: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node9, node10, node11, + node12); + case 8: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node, node10, node11, + node12); + case 9: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node11, + node12); + case 10: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node12); + case 11: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11, node12); + case 5: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11, node12); + case 6: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11, node12); + case 7: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11, node12); + case 8: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11, node12); + case 9: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11, node12); + case 10: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11, node12); + case 11: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node, node12); + case 12: + return nodeOf13x3(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11, node12); + case 5: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11, node12); + case 6: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11, node12); + case 7: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11, node12); + case 8: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11, node12); + case 9: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11, node12); + case 10: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11, node12); + case 11: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node, node12); + case 12: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11, node12); + case 5: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11, node12); + case 6: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11, node12); + case 7: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11, node12); + case 8: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11, node12); + case 9: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11, node12); + case 10: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11, node12); + case 11: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node, node12); + case 12: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12); + case 1: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11, node12); + case 5: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11, node12); + case 6: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11, node12); + case 7: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11, node12); + case 8: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11, node12); + case 9: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11, node12); + case 10: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11, node12); + case 11: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node, node12); + case 12: + return nodeOf13x3(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, + node12, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4, node5, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node5, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node6, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node7, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node8, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node9, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node10, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node11, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node12); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node12); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node12); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node12); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node12); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (valIndex) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + + private Map5To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 10; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5); + case 1: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5); + case 2: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5); + case 3: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5); + case 4: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5); + case 1: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5); + case 2: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5); + case 3: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5); + case 4: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5); + case 5: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5); + case 1: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5); + case 2: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5); + case 3: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5); + case 4: + return nodeOf0x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map5To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + + private Map5To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 11; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1); + case 1: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1); + case 2: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1); + case 3: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1); + case 4: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1); + case 1: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1); + case 2: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1); + case 3: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1); + case 4: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1); + case 5: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1); + case 1: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1); + case 2: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1); + case 3: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1); + case 4: + return nodeOf1x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5); + case 1: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5); + case 2: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5); + case 3: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5); + case 4: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5); + case 5: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map5To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2); + case 2: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2); + case 3: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2); + case 4: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2); + case 2: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2); + case 3: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2); + case 4: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2); + case 5: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2); + case 1: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2); + case 2: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2); + case 3: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2); + case 4: + return nodeOf2x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2); + case 1: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2); + case 2: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2); + case 3: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2); + case 4: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2); + case 5: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1); + case 1: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1); + case 2: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1); + case 3: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1); + case 4: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1); + case 5: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map5To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3); + case 1: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3); + case 2: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3); + case 3: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3); + case 4: + return nodeOf3x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3); + case 2: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3); + case 3: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3); + case 4: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3); + case 5: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3); + case 2: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3); + case 3: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3); + case 4: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3); + case 5: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2); + case 2: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2); + case 3: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2); + case 4: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2); + case 5: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To4Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map5To4Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3, node4); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3, node4); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4); + case 1: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4); + case 2: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4); + case 3: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4); + case 4: + return nodeOf4x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To5Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map5To5Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To6Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map5To6Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5, node6); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5, node6); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5, node6); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5, node6); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5, node6); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5, node6); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5, node6); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5, node6); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node6); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node6); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To7Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map5To7Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5, node6, node7); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5, node6, node7); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node6, node7); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node7); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5, node6, node7); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5, node6, node7); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5, node6, node7); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node6, node7); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node7); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To8Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map5To8Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5, node6, node7, node8); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node6, node7, node8); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node7, node8); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node8); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5, node6, node7, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5, node6, node7, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5, node6, node7, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5, node6, node7, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node6, node7, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node7, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node8); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To9Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map5To9Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node6, node7, node8, node9); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node7, node8, node9); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node8, node9); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node, node9); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5, node6, node7, node8, node9); + case 5: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node6, node7, node8, node9); + case 6: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node7, node8, node9); + case 7: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node8, node9); + case 8: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node, node9); + case 9: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To10Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map5To10Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf10x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 1: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 2: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 3: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + case 4: + return nodeOf10x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node6, node7, node8, node9, + node10); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node7, node8, node9, + node10); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node8, node9, + node10); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node, node9, + node10); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node, + node10); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, + node10); + case 5: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, + node10); + case 6: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, + node10); + case 7: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, + node10); + case 8: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, + node10); + case 9: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, + node10); + case 10: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, + node10); + case 5: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, + node10); + case 6: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, + node10); + case 7: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, + node10); + case 8: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, + node10); + case 9: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, + node10); + case 10: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, + node10); + case 5: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, + node10); + case 6: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, + node10); + case 7: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, + node10); + case 8: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, + node10); + case 9: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, + node10); + case 10: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, + node10); + case 5: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, + node10); + case 6: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, + node10); + case 7: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, + node10); + case 8: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, + node10); + case 9: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, + node10); + case 10: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, + node10); + case 5: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, + node10); + case 6: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, + node10); + case 7: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, + node10); + case 8: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, + node10); + case 9: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, + node10); + case 10: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map5To11Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + private final CompactMapNode node11; + + private Map5To11Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9, final CompactMapNode node10, final CompactMapNode node11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + this.node11 = node11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 21; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node11; + case 1: + return node10; + case 2: + return node9; + case 3: + return node8; + case 4: + return node7; + case 5: + return node6; + case 6: + return node5; + case 7: + return node4; + case 8: + return node3; + case 9: + return node2; + case 10: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 11; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 5; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf11x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 1: + return nodeOf11x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 2: + return nodeOf11x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 3: + return nodeOf11x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 4: + return nodeOf11x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 5: + return nodeOf11x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf11x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 1: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 2: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 3: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + case 4: + return nodeOf11x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node3, node4, node5, node6, node7, node8, node9, + node10, node11); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node4, node5, node6, node7, node8, node9, + node10, node11); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node5, node6, node7, node8, node9, + node10, node11); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node6, node7, node8, node9, + node10, node11); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node7, node8, node9, + node10, node11); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node8, node9, + node10, node11); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node, node9, + node10, node11); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node, + node10, node11); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, + node11); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x4(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 1: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 2: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3, node4, node5, node6, node7, node8, node9, node10, + node11); + case 3: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node, node4, node5, node6, node7, node8, node9, node10, + node11); + case 4: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node, node5, node6, node7, node8, node9, node10, + node11); + case 5: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node, node6, node7, node8, node9, node10, + node11); + case 6: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node, node7, node8, node9, node10, + node11); + case 7: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node, node8, node9, node10, + node11); + case 8: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node, node9, node10, + node11); + case 9: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node, node10, + node11); + case 10: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node, + node11); + case 11: + return nodeOf12x4(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, + node11, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3, node4, node5, node6, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node4, node5, node6, node7, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node4, node5, node6, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node5, node6, node7, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node5, node6, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node6, node7, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node6, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node7, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node7, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node8, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node8, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node9, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node9, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node10, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node8, node10, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node11); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node11); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node11); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node11); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node11); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node11); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (valIndex) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + + private Map6To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 12; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6); + case 1: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6); + case 2: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6); + case 3: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6); + case 4: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6); + case 5: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6); + case 1: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6); + case 2: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6); + case 3: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6); + case 4: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6); + case 5: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6); + case 6: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6); + case 1: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6); + case 2: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6); + case 3: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6); + case 4: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6); + case 5: + return nodeOf0x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map6To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final CompactMapNode node1; + + private Map6To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 13; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1); + case 1: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1); + case 2: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1); + case 3: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1); + case 4: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1); + case 5: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 1: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 2: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 3: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1); + case 4: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1); + case 5: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1); + case 6: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1); + case 1: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1); + case 2: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1); + case 3: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1); + case 4: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1); + case 5: + return nodeOf1x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6); + case 1: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6); + case 2: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6); + case 3: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6); + case 4: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6); + case 5: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6); + case 6: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map6To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2); + case 2: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2); + case 3: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2); + case 4: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2); + case 5: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2); + case 2: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2); + case 3: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2); + case 4: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2); + case 5: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2); + case 6: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2); + case 1: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2); + case 2: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2); + case 3: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2); + case 4: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2); + case 5: + return nodeOf2x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2); + case 1: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2); + case 2: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2); + case 3: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2); + case 4: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2); + case 5: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2); + case 6: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1); + case 1: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1); + case 2: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1); + case 3: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1); + case 4: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1); + case 5: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1); + case 6: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map6To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3); + case 1: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3); + case 2: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3); + case 3: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3); + case 4: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3); + case 5: + return nodeOf3x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3); + case 2: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3); + case 3: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3); + case 4: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3); + case 5: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3); + case 6: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3); + case 2: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3); + case 3: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3); + case 4: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3); + case 5: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3); + case 6: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2); + case 2: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2); + case 3: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2); + case 4: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2); + case 5: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2); + case 6: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To4Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map6To4Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3, node4); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4); + case 1: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4); + case 2: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4); + case 3: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4); + case 4: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4); + case 5: + return nodeOf4x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To5Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map6To5Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4, node5); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4, node5); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4, node5); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node5); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4, node5); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4, node5); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4, node5); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4, node5); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4, node5); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4, node5); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node5); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node5); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To6Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map6To6Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4, node5, node6); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4, node5, node6); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4, node5, node6); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4, node5, node6); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4, node5, node6); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4, node5, node6); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node5, node6); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node5, node6); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node6); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node6); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To7Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map6To7Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf7x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4, node5, node6, node7); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node5, node6, node7); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node6, node7); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node7); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4, node5, node6, node7); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4, node5, node6, node7); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node5, node6, node7); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node6, node7); + case 6: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node7); + case 7: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4, node5, node6, node7); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4, node5, node6, node7); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4, node5, node6, node7); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node5, node6, node7); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node6, node7); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node7); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To8Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map6To8Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + case 5: + return nodeOf8x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node5, node6, node7, node8); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node6, node7, node8); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node7, node8); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node8); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4, node5, node6, node7, node8); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node5, node6, node7, node8); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node6, node7, node8); + case 6: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node7, node8); + case 7: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node, node8); + case 8: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4, node5, node6, node7, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4, node5, node6, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4, node5, node6, node7, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4, node5, node6, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4, node5, node6, node7, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4, node5, node6, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node5, node6, node7, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node5, node6, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node6, node7, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node6, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node7, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node7, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node8); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node8); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node8); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To9Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map6To9Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 21; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 1: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 2: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 3: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 4: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9); + case 5: + return nodeOf9x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node5, node6, node7, node8, + node9); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node6, node7, node8, + node9); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node7, node8, + node9); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node8, + node9); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, + node9); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9); + case 6: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9); + case 7: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9); + case 8: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9); + case 9: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4, node5, node6, node7, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4, node5, node6, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4, node5, node6, node7, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4, node5, node6, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4, node5, node6, node7, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4, node5, node6, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node5, node6, node7, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node5, node6, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node6, node7, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node6, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node7, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node7, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node8, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node8, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node8, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node9); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node9); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node9); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node9); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node9); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node9); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map6To10Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + private final CompactMapNode node10; + + private Map6To10Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9, final CompactMapNode node10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + this.node10 = node10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 22; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node10; + case 1: + return node9; + case 2: + return node8; + case 3: + return node7; + case 4: + return node6; + case 5: + return node5; + case 6: + return node4; + case 7: + return node3; + case 8: + return node2; + case 9: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 10; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 6; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf10x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 1: + return nodeOf10x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 2: + return nodeOf10x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 3: + return nodeOf10x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 4: + return nodeOf10x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + case 5: + return nodeOf10x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + case 6: + return nodeOf10x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf10x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 1: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 2: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 3: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 4: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + case 5: + return nodeOf10x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node6, node7, node8, + node9, node10); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node7, node8, + node9, node10); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node8, + node9, node10); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, + node9, node10); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node, node10); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9, node10); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9, node10); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9, node10); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9, node10); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node, node10); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9, node10); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9, node10); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9, node10); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9, node10); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node, node10); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9, node10); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9, node10); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9, node10); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9, node10); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node, node10); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9, node10); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9, node10); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9, node10); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9, node10); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node, node10); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9, node10); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9, node10); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9, node10); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9, node10); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node, node10); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 1: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2, node3, node4, node5, node6, node7, node8, + node9, node10); + case 2: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node, node3, node4, node5, node6, node7, node8, + node9, node10); + case 3: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node, node4, node5, node6, node7, node8, + node9, node10); + case 4: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node, node5, node6, node7, node8, + node9, node10); + case 5: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node, node6, node7, node8, + node9, node10); + case 6: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node, node7, node8, + node9, node10); + case 7: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node, node8, + node9, node10); + case 8: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node, + node9, node10); + case 9: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node, node10); + case 10: + return nodeOf11x5(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node3, node4, node5, node6, node7, node8, node9, + node10, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, + node7, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2, node3, node4, node5, node6, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, + node7, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node3, node4, node5, node6, node7, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node3, node4, node5, node6, node7, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node3, node4, node5, node6, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, + node7, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node4, node5, node6, node7, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node4, node5, node6, node7, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node4, node5, node6, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, + node7, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node5, node6, node7, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node5, node6, node7, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node5, node6, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, + node7, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node6, node7, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node6, node7, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node6, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node7, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node7, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node7, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node7, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node8, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node8, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node8, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node8, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node8, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node9, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node9, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node9, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node9, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node9, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node9, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node9, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8, node10); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8, node10); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8, node10); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node10); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node10); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node10); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node8, node10); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (valIndex) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + + private Map7To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 14; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7); + case 1: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7); + case 2: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7); + case 3: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7); + case 4: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7); + case 5: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7); + case 6: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 1: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 2: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 3: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7); + case 4: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7); + case 5: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7); + case 6: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7); + case 7: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7); + case 1: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7); + case 2: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7); + case 3: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7); + case 4: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7); + case 5: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7); + case 6: + return nodeOf0x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map7To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final CompactMapNode node1; + + private Map7To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 15; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + case 1: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + case 2: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + case 3: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1); + case 4: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1); + case 5: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1); + case 6: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 1: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 2: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 3: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 4: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1); + case 5: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1); + case 6: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1); + case 7: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1); + case 1: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1); + case 2: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1); + case 3: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1); + case 4: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1); + case 5: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1); + case 6: + return nodeOf1x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7); + case 1: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7); + case 2: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7); + case 3: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7); + case 4: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7); + case 5: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7); + case 6: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7); + case 7: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map7To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2); + case 2: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2); + case 3: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2); + case 4: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2); + case 5: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2); + case 6: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 2: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 3: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 4: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2); + case 5: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2); + case 6: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2); + case 7: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2); + case 1: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2); + case 2: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2); + case 3: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2); + case 4: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2); + case 5: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2); + case 6: + return nodeOf2x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2); + case 1: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2); + case 2: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2); + case 3: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2); + case 4: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2); + case 5: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2); + case 6: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2); + case 7: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 1: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 2: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 3: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 4: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1); + case 5: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1); + case 6: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1); + case 7: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map7To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3); + case 1: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3); + case 2: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3); + case 3: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3); + case 4: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3); + case 5: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3); + case 6: + return nodeOf3x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3); + case 2: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3); + case 3: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3); + case 4: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3); + case 5: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3); + case 6: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3); + case 7: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3); + case 2: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3); + case 3: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3); + case 4: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3); + case 5: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3); + case 6: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3); + case 7: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 2: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 3: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2); + case 4: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2); + case 5: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2); + case 6: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2); + case 7: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To4Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map7To4Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3, node4); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3, node4); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 1: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 2: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 3: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 4: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4); + case 5: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4); + case 6: + return nodeOf4x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3, node4); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3, node4); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node4); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3, node4); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3, node4); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3, node4); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node4); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3, node4); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3, node4); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3, node4); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3, node4); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3, node4); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3, node4); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node4); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node4); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node4); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To5Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map7To5Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3, node4, node5); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3, node4, node5); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node4, node5); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node5); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3, node4, node5); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3, node4, node5); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3, node4, node5); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3, node4, node5); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node4, node5); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node4, node5); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node5); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node5); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To6Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map7To6Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3, node4, node5, node6); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, node5, + node6); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6); + case 6: + return nodeOf6x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3, node4, node5, node6); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3, node4, node5, node6); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node4, node5, node6); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node5, node6); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node6); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3, node4, node5, + node6); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3, node4, node5, + node6); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3, node4, node5, + node6); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3, node4, node5, + node6); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node4, node5, + node6); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node4, node5, + node6); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node5, + node6); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node5, + node6); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node6); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node6); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To7Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map7To7Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 21; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3, node4, node5, node6, + node7); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, node5, + node6, node7); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7); + case 6: + return nodeOf7x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3, node4, node5, node6, + node7); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node4, node5, node6, + node7); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node5, node6, + node7); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node6, + node7); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, + node7); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3, node4, node5, node6, + node7); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node4, node5, node6, + node7); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node5, node6, + node7); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node6, + node7); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node, + node7); + case 7: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3, node4, node5, + node6, node7); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3, node4, node5, + node6, node7); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node4, node5, + node6, node7); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node5, + node6, node7); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node6, node7); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node7); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node6); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To8Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map7To8Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 22; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8); + case 1: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8); + case 2: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8); + case 3: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8); + case 4: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8); + case 5: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8); + case 6: + return nodeOf8x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node4, node5, node6, + node7, node8); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node5, node6, + node7, node8); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node6, + node7, node8); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, + node7, node8); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node, node8); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node4, node5, node6, + node7, node8); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node5, node6, + node7, node8); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node6, + node7, node8); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node, + node7, node8); + case 7: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node, node8); + case 8: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3, node4, node5, + node6, node7, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3, node4, node5, + node6, node7, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node4, node5, + node6, node7, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node5, + node6, node7, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node6, node7, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node7, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node6, node8); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node6, node7); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map7To9Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + private final CompactMapNode node9; + + private Map7To9Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + this.node9 = node9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 23; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node9; + case 1: + return node8; + case 2: + return node7; + case 3: + return node6; + case 4: + return node5; + case 5: + return node4; + case 6: + return node3; + case 7: + return node2; + case 8: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8, node9); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 9; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 7; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf9x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 4: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 5: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 6: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + case 7: + return nodeOf9x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf9x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 1: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 2: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 3: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 4: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 5: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + case 6: + return nodeOf9x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, node8, + node9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node5, node6, + node7, node8, node9); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node6, + node7, node8, node9); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, + node7, node8, node9); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node, node8, node9); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node, node9); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1, node2, node3, node4, node5, node6, + node7, node8, node9); + case 1: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node, node2, node3, node4, node5, node6, + node7, node8, node9); + case 2: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node, node3, node4, node5, node6, + node7, node8, node9); + case 3: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node, node4, node5, node6, + node7, node8, node9); + case 4: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node, node5, node6, + node7, node8, node9); + case 5: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node, node6, + node7, node8, node9); + case 6: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node, + node7, node8, node9); + case 7: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node, node8, node9); + case 8: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node, node9); + case 9: + return nodeOf10x6(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node2, node3, node4, node5, node6, node7, + node8, node9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node2, node3, node4, node5, + node6, node7, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node2, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node3, node4, node5, + node6, node7, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node3, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node4, node5, + node6, node7, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node4, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node5, + node6, node7, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node5, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node6, node7, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node6, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node7, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node7, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node6, node8, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node6, node8, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node9); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node6, node7, node9); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (valIndex) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, node1, node2, node3, node4, + node5, node6, node7, node8); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, node1, node2, node3, node4, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + + private Map8To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 16; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8); + case 6: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8); + case 7: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8); + case 6: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8); + case 7: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8); + case 8: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8); + case 6: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8); + case 7: + return nodeOf0x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map8To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final CompactMapNode node1; + + private Map8To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 17; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 1: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 2: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 3: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 4: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1); + case 5: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1); + case 6: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1); + case 7: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 1: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 2: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 3: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 4: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 5: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1); + case 6: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1); + case 7: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1); + case 8: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1); + case 1: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1); + case 2: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1); + case 3: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1); + case 4: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1); + case 5: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1); + case 6: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1); + case 7: + return nodeOf1x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8); + case 6: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8); + case 7: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8); + case 8: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map8To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 2: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 3: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 4: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2); + case 5: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2); + case 6: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2); + case 7: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 2: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 3: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 4: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 5: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2); + case 6: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2); + case 7: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2); + case 8: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 1: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 2: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 3: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 4: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2); + case 5: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2); + case 6: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2); + case 7: + return nodeOf2x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2); + case 1: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2); + case 2: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2); + case 3: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2); + case 4: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2); + case 5: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2); + case 6: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2); + case 7: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2); + case 8: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 1: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 2: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 3: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 4: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1); + case 5: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1); + case 6: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1); + case 7: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1); + case 8: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map8To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2, node3); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2, node3); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, node3); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, node3); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 1: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 2: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 3: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 4: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3); + case 5: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3); + case 6: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3); + case 7: + return nodeOf3x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2, node3); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node3); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2, node3); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2, node3); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node3); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3); + case 2: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3); + case 3: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3); + case 4: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3); + case 5: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2, node3); + case 6: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2, node3); + case 7: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2, node3); + case 8: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3); + case 2: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3); + case 3: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3); + case 4: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3); + case 5: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node3); + case 6: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node3); + case 7: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node3); + case 8: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 2: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 3: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 4: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + case 5: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2); + case 6: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2); + case 7: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2); + case 8: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To4Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map8To4Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2, node3, node4); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2, node3, node4); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, node3, + node4); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, node3, + node4); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 1: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 2: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 3: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 4: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + case 5: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4); + case 6: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4); + case 7: + return nodeOf4x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2, node3, node4); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node3, node4); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node4); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2, node3, node4); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2, node3, node4); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node3, node4); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node4); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2, node3, + node4); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2, node3, + node4); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2, node3, + node4); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node3, + node4); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node3, + node4); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node3, + node4); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node4); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node4); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node4); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To5Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map8To5Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 21; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2, node3, node4, + node5); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2, node3, node4, + node5); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, node3, + node4, node5); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, node3, + node4, node5); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5); + case 7: + return nodeOf5x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2, node3, node4, + node5); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node3, node4, + node5); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node4, + node5); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node5); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2, node3, + node4, node5); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2, node3, + node4, node5); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node3, + node4, node5); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node3, + node4, node5); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node4, node5); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node4, node5); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node5); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node5); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To6Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map8To6Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 22; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2, node3, node4, + node5, node6); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, node3, + node4, node5, node6); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6); + case 6: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, node6); + case 7: + return nodeOf6x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2, node3, node4, + node5, node6); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node3, node4, + node5, node6); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node4, + node5, node6); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node5, node6); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node, node6); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2, node3, + node4, node5, node6); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2, node3, + node4, node5, node6); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node3, + node4, node5, node6); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node3, + node4, node5, node6); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node4, node5, node6); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node4, node5, node6); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node5, node6); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node5, node6); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node6); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node6); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node5); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node5); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To7Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map8To7Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 23; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2, node3, node4, + node5, node6, node7); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, node3, + node4, node5, node6, node7); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 2: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 3: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 4: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 5: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 6: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, node6, + node7); + case 7: + return nodeOf7x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2, node3, node4, + node5, node6, node7); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node3, node4, + node5, node6, node7); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node4, + node5, node6, node7); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node5, node6, node7); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node, node6, node7); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node, node7); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node, node7); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2, node3, + node4, node5, node6, node7); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node3, + node4, node5, node6, node7); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node4, node5, node6, node7); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node5, node6, node7); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node6, node7); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node5, node7); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node5, node6); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map8To8Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + private Map8To8Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 24; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node8; + case 1: + return node7; + case 2: + return node6; + case 3: + return node5; + case 4: + return node4; + case 5: + return node3; + case 6: + return node2; + case 7: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7, node8); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 8; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 8; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7, node8); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7, node8); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, node1, node2, node3, node4, + node5, node6, node7, node8); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, node1, node2, node3, node4, + node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf8x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 3: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 4: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 5: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 6: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 7: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, node3, + node4, node5, node6, node7, node8); + case 8: + return nodeOf8x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf8x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 1: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 2: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 3: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 4: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 5: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 6: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, node6, + node7, node8); + case 7: + return nodeOf8x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node2, node3, node4, + node5, node6, node7, node8); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node3, node4, + node5, node6, node7, node8); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node4, + node5, node6, node7, node8); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node5, node6, node7, node8); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node, node6, node7, node8); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node, node7, node8); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node, node8); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node, node1, node2, node3, node4, node5, + node6, node7, node8); + case 1: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node, node2, node3, node4, node5, + node6, node7, node8); + case 2: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node, node3, node4, node5, + node6, node7, node8); + case 3: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node, node4, node5, + node6, node7, node8); + case 4: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node, node5, + node6, node7, node8); + case 5: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, node, + node6, node7, node8); + case 6: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node, node7, node8); + case 7: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node, node8); + case 8: + return nodeOf9x7(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node1, node2, node3, node4, node5, + node6, node7, node8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node2, node3, + node4, node5, node6, node7, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node2, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node3, + node4, node5, node6, node7, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node3, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node4, node5, node6, node7, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node4, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node5, node6, node7, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node5, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node6, node7, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node5, node7, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node5, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node5, node6, node8); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node5, node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, node1, node2, + node3, node4, node5, node6, node7); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, node1, node2, + node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + + private Map9To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 18; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 1: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 2: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 3: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 4: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9); + case 5: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9); + case 6: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9); + case 7: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9); + case 8: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 1: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 2: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 3: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 4: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 5: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9); + case 6: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9); + case 7: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9); + case 8: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9); + case 9: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 1: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 2: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 3: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 4: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9); + case 5: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9); + case 6: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9); + case 7: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9); + case 8: + return nodeOf0x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map9To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final CompactMapNode node1; + + private Map9To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 19; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 1: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 2: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 3: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 4: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 5: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1); + case 6: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1); + case 7: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1); + case 8: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 1: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 2: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 3: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 4: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 5: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 6: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1); + case 7: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1); + case 8: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1); + case 9: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 1: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 2: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 3: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 4: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1); + case 5: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1); + case 6: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1); + case 7: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1); + case 8: + return nodeOf1x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 1: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 2: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 3: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 4: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + case 5: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9); + case 6: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9); + case 7: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9); + case 8: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9); + case 9: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map9To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 2: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 3: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 4: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 5: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1, node2); + case 6: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1, node2); + case 7: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1, node2); + case 8: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 2: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 3: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 4: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2); + case 5: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2); + case 6: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2); + case 7: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2); + case 8: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2); + case 9: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 1: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 2: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 3: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 4: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + case 5: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2); + case 6: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2); + case 7: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2); + case 8: + return nodeOf2x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node2); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1, node2); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node2); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2); + case 1: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2); + case 2: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2); + case 3: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2); + case 4: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2); + case 5: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, + node2); + case 6: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, + node2); + case 7: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, + node2); + case 8: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, + node2); + case 9: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + case 1: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + case 2: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + case 3: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + case 4: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + case 5: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, + node1); + case 6: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, + node1); + case 7: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, + node1); + case 8: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, + node1); + case 9: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map9To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 21; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1, node2, node3); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1, node2, node3); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 1: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 2: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 3: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 4: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 5: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3); + case 6: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3); + case 7: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3); + case 8: + return nodeOf3x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node2, node3); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node3); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3); + case 2: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3); + case 3: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3); + case 4: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3); + case 5: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3); + case 6: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node2, + node3); + case 7: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node2, + node3); + case 8: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node2, + node3); + case 9: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3); + case 2: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3); + case 3: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3); + case 4: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3); + case 5: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3); + case 6: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node3); + case 7: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node3); + case 8: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node3); + case 9: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2); + case 2: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2); + case 3: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2); + case 4: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2); + case 5: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2); + case 6: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2); + case 7: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2); + case 8: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2); + case 9: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To4Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map9To4Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 22; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1, node2, node3, + node4); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1, node2, node3, + node4); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4); + case 1: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4); + case 2: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4); + case 3: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4); + case 4: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4); + case 5: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4); + case 6: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4); + case 7: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4); + case 8: + return nodeOf4x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node2, node3, + node4); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node3, + node4); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, + node4); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, + node4); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, + node4); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, + node4); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node4); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node2, + node3, node4); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node2, + node3, node4); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node2, + node3, node4); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node3, node4); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node3, node4); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node3, node4); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node4); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node4); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node4); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To5Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map9To5Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 23; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1, node2, node3, + node4, node5); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node5); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 1: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 2: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 3: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 4: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 5: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 6: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5); + case 7: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5); + case 8: + return nodeOf5x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node2, node3, + node4, node5); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node3, + node4, node5); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, + node4, node5); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node, node5); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, + node4, node5); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, + node4, node5); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, + node4, node5); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node4, node5); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node, node5); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node2, + node3, node4, node5); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node2, + node3, node4, node5); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node2, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node3, node4, node5); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node3, node4, node5); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node4, node5); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node4, node5); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node5); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node5); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To6Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map9To6Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 24; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1, node2, node3, + node4, node5, node6); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node5, node6); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 2: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 3: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 4: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 5: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 6: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6); + case 7: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node6); + case 8: + return nodeOf6x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node2, node3, + node4, node5, node6); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node3, + node4, node5, node6); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, + node4, node5, node6); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node, node5, node6); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node, node6); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, + node4, node5, node6); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, + node4, node5, node6); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node4, node5, node6); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node, node5, node6); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5, node6); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5, node6); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5, node6); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node2, + node3, node4, node5, node6); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node2, + node3, node4, node5, node6); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node2, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5, node6); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5, node6); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5, node6); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node3, node4, node5, node6); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node3, node4, node5, node6); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5, node6); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5, node6); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5, node6); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node4, node5, node6); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node4, node5, node6); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5, node6); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5, node6); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5, node6); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node5, node6); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node5, node6); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node6); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node6); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node6); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node6); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node6); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node5); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node5); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map9To7Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + private Map9To7Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 25; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node7; + case 1: + return node6; + case 2: + return node5; + case 3: + return node4; + case 4: + return node3; + case 5: + return node2; + case 6: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6, node7); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 7; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 9; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 7: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, node1, node2, node3, + node4, node5, node6, node7); + case 8: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, node1, node2, node3, + node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf7x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6, node7); + case 1: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6, node7); + case 2: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6, node7); + case 3: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6, node7); + case 4: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6, node7); + case 5: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6, node7); + case 6: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6, node7); + case 7: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6, node7); + case 8: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node5, node6, node7); + case 9: + return nodeOf7x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf7x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 1: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 2: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 3: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 4: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 5: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 6: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 7: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node6, node7); + case 8: + return nodeOf7x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node3, + node4, node5, node6, node7); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, + node4, node5, node6, node7); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node, node5, node6, node7); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node, node6, node7); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node, node7); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node, node1, node2, node3, + node4, node5, node6, node7); + case 1: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node, node2, node3, + node4, node5, node6, node7); + case 2: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node, node3, + node4, node5, node6, node7); + case 3: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node, + node4, node5, node6, node7); + case 4: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node, node5, node6, node7); + case 5: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node, node6, node7); + case 6: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node, node7); + case 7: + return nodeOf8x8(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, node1, node2, node3, node4, + node5, node6, node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node2, node3, node4, node5, node6, node7); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5, node6, node7); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5, node6, node7); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node2, + node3, node4, node5, node6, node7); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node2, + node3, node4, node5, node6, node7); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node2, + node3, node4, node5, node6, node7); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node2, + node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6, node7); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6, node7); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6, node7); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node3, node4, node5, node6, node7); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5, node6, node7); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5, node6, node7); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node3, node4, node5, node6, node7); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node3, node4, node5, node6, node7); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node3, node4, node5, node6, node7); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6, node7); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6, node7); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6, node7); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node4, node5, node6, node7); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5, node6, node7); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5, node6, node7); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node4, node5, node6, node7); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node4, node5, node6, node7); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node4, node5, node6, node7); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6, node7); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6, node7); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6, node7); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node5, node6, node7); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5, node6, node7); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5, node6, node7); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node5, node6, node7); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node5, node6, node7); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node5, node6, node7); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6, node7); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6, node7); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6, node7); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node6, node7); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node6, node7); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node6, node7); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node6, node7); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node6, node7); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node6, node7); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node7); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node7); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node7); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node7); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node7); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node7); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node7); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node7); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node5, node7); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, node1, + node2, node3, node4, node5, node6); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, node1, + node2, node3, node4, node5, node6); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map10To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + + private Map10To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 20; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 1: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 2: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 3: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 4: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 5: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10); + case 6: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10); + case 7: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10); + case 8: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10); + case 9: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 1: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 2: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 3: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 4: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10); + case 5: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10); + case 6: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10); + case 7: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10); + case 8: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10); + case 9: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10); + case 10: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 1: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 2: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 3: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 4: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + case 5: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10); + case 6: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10); + case 7: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10); + case 8: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10); + case 9: + return nodeOf0x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map10To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final CompactMapNode node1; + + private Map10To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 21; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 1: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 2: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 3: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 4: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 5: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 6: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, node1); + case 7: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, node1); + case 8: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, node1); + case 9: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 1: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 2: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 3: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + case 4: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + case 5: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + case 6: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + case 7: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1); + case 8: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1); + case 9: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1); + case 10: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 1: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 2: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 3: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 4: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 5: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1); + case 6: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1); + case 7: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1); + case 8: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1); + case 9: + return nodeOf1x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10); + case 1: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10); + case 2: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10); + case 3: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10); + case 4: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10); + case 5: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10); + case 6: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10); + case 7: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10); + case 8: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10); + case 9: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10); + case 10: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map10To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map10To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 22; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + case 2: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + case 3: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + case 4: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + case 5: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + case 6: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, node1, + node2); + case 7: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, node1, + node2); + case 8: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, node1, + node2); + case 9: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2); + case 2: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2); + case 3: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2); + case 4: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + case 5: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + case 6: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + case 7: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2); + case 8: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2); + case 9: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2); + case 10: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2); + case 1: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2); + case 2: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2); + case 3: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2); + case 4: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2); + case 5: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2); + case 6: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2); + case 7: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2); + case 8: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2); + case 9: + return nodeOf2x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, + node2); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, + node2); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, + node2); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2); + case 1: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2); + case 2: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2); + case 3: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2); + case 4: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2); + case 5: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2); + case 6: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node2); + case 7: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node2); + case 8: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node2); + case 9: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node2); + case 10: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1); + case 1: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1); + case 2: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1); + case 3: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1); + case 4: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + case 5: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + case 6: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1); + case 7: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1); + case 8: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1); + case 9: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1); + case 10: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map10To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map10To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 23; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, node1, + node2, node3); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, node1, + node2, node3); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 1: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 2: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 3: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 4: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 5: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 6: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3); + case 7: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3); + case 8: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3); + case 9: + return nodeOf3x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, + node2, node3); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node, node3); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, + node2, node3); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, + node2, node3); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node, node3); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3); + case 2: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3); + case 3: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3); + case 4: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3); + case 5: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3); + case 6: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3); + case 7: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node2, node3); + case 8: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node2, node3); + case 9: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node2, node3); + case 10: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3); + case 2: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3); + case 3: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3); + case 4: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3); + case 5: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3); + case 6: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3); + case 7: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node3); + case 8: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node3); + case 9: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node3); + case 10: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2); + case 2: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2); + case 3: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2); + case 4: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + case 5: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + case 6: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2); + case 7: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2); + case 8: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2); + case 9: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2); + case 10: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map10To4Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map10To4Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 24; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, node1, + node2, node3, node4); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, node1, + node2, node3, node4); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node4); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node4); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 1: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 2: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 3: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 4: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 5: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 6: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4); + case 7: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4); + case 8: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4); + case 9: + return nodeOf4x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, + node2, node3, node4); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node, node3, node4); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node, node4); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, + node2, node3, node4); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, + node2, node3, node4); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node, node3, node4); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node, node4); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node2, node3, node4); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node2, node3, node4); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node2, node3, node4); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node3, node4); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node3, node4); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node3, node4); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node4); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node4); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node4); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map10To5Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map10To5Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 25; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, node1, + node2, node3, node4, node5); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node4, node5); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 1: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 2: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 3: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 4: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 5: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 6: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 7: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node5); + case 8: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node5); + case 9: + return nodeOf5x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, + node2, node3, node4, node5); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node, node3, node4, node5); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node, node4, node5); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node, node5); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, + node2, node3, node4, node5); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, + node2, node3, node4, node5); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node, node3, node4, node5); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node, node4, node5); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node, node5); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node2, node3, node4, node5); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node2, node3, node4, node5); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node3, node4, node5); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node3, node4, node5); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node4, node5); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node4, node5); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node5); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node5); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node4); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node4); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map10To6Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + private Map10To6Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 26; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node6; + case 1: + return node5; + case 2: + return node4; + case 3: + return node3; + case 4: + return node2; + case 5: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5, node6); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 6; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 10; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 6: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 7: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node6); + case 8: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, node1, + node2, node3, node4, node5, node6); + case 9: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, node1, + node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf6x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5, node6); + case 2: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5, node6); + case 3: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5, node6); + case 4: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5, node6); + case 5: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5, node6); + case 6: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5, node6); + case 7: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5, node6); + case 8: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node4, node5, node6); + case 9: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node4, node5, node6); + case 10: + return nodeOf6x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf6x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 1: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 2: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 3: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 4: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 5: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 6: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 7: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6); + case 8: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node5, node6); + case 9: + return nodeOf6x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, + node2, node3, node4, node5, node6); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node, node3, node4, node5, node6); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node, node4, node5, node6); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node, node5, node6); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node, node6); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node, node1, + node2, node3, node4, node5, node6); + case 1: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node, + node2, node3, node4, node5, node6); + case 2: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node, node3, node4, node5, node6); + case 3: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node, node4, node5, node6); + case 4: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node, node5, node6); + case 5: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node, node6); + case 6: + return nodeOf7x9(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, node1, node2, + node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5, node6); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5, node6); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5, node6); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node2, node3, node4, node5, node6); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5, node6); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5, node6); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5, node6); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node2, node3, node4, node5, node6); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node2, node3, node4, node5, node6); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node2, node3, node4, node5, node6); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5, node6); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5, node6); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5, node6); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node3, node4, node5, node6); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5, node6); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5, node6); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5, node6); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node3, node4, node5, node6); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node3, node4, node5, node6); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node3, node4, node5, node6); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5, node6); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5, node6); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5, node6); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node4, node5, node6); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5, node6); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5, node6); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5, node6); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node4, node5, node6); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node4, node5, node6); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node4, node5, node6); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5, node6); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5, node6); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5, node6); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node5, node6); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5, node6); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5, node6); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5, node6); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node5, node6); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node5, node6); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node5, node6); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node6); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node6); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node6); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node6); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node6); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node6); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node6); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node6); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node4, node6); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node4, node6); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, node1, node2, node3, node4, node5); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, node1, node2, node3, node4, node5); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map11To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + + private Map11To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 22; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 11; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + case 1: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + case 2: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + case 3: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + case 4: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + case 5: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + case 6: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11); + case 7: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11); + case 8: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11); + case 9: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11); + case 10: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11); + case 1: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11); + case 2: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11); + case 3: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11); + case 4: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + case 5: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + case 6: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + case 7: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11); + case 8: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11); + case 9: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11); + case 10: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11); + case 11: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11); + case 1: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11); + case 2: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11); + case 3: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11); + case 4: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11); + case 5: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11); + case 6: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11); + case 7: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11); + case 8: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11); + case 9: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11); + case 10: + return nodeOf0x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map11To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final CompactMapNode node1; + + private Map11To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 23; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 11; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 1: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 2: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 3: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 4: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 5: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 6: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + case 7: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, node1); + case 8: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, node1); + case 9: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, node1); + case 10: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1); + case 1: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1); + case 2: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1); + case 3: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1); + case 4: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 5: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 6: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 7: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 8: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1); + case 9: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1); + case 10: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, node1); + case 11: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 1: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 2: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 3: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 4: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 5: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 6: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1); + case 7: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1); + case 8: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1); + case 9: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1); + case 10: + return nodeOf1x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node, node1); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11); + case 1: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11); + case 2: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11); + case 3: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11); + case 4: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + case 5: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + case 6: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11); + case 7: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11); + case 8: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11); + case 9: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11); + case 10: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11); + case 11: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map11To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map11To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 24; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 11; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 2: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 3: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 4: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 5: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 6: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + case 7: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, node1, node2); + case 8: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, node1, node2); + case 9: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, node1, node2); + case 10: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2); + case 2: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2); + case 3: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2); + case 4: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 5: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 6: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 7: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 8: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2); + case 9: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2); + case 10: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, node1, node2); + case 11: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 1: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 2: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 3: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 4: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 5: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 6: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2); + case 7: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2); + case 8: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2); + case 9: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, node1, + node2); + case 10: + return nodeOf2x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node, node2); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node, node1, node2); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node, node2); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2); + case 1: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2); + case 2: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2); + case 3: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2); + case 4: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2); + case 5: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2); + case 6: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2); + case 7: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node2); + case 8: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node2); + case 9: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node2); + case 10: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node2); + case 11: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1); + case 1: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1); + case 2: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1); + case 3: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1); + case 4: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 5: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 6: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 7: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1); + case 8: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1); + case 9: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1); + case 10: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1); + case 11: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map11To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map11To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 25; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 11; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, node1, node2, node3); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, node1, node2, node3); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node3); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, node1, node2, node3); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 1: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 2: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 3: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 4: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 5: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 6: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 7: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3); + case 8: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3); + case 9: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, node1, + node2, node3); + case 10: + return nodeOf3x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node, node2, node3); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node, node3); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node, node1, node2, node3); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node, node2, node3); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node, node3); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3); + case 2: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3); + case 3: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3); + case 4: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3); + case 5: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3); + case 6: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3); + case 7: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3); + case 8: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node2, node3); + case 9: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node2, node3); + case 10: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node2, node3); + case 11: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3); + case 2: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3); + case 3: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3); + case 4: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3); + case 5: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3); + case 6: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3); + case 7: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3); + case 8: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node3); + case 9: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node3); + case 10: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node3); + case 11: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2); + case 2: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2); + case 3: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2); + case 4: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 5: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 6: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 7: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2); + case 8: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2); + case 9: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2); + case 10: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node2); + case 11: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map11To4Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map11To4Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 26; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 11; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, node1, node2, node3, node4); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, node1, node2, node3, node4); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node3, node4); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, node1, node2, node3, node4); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 1: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 2: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 3: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 4: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 5: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 6: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 7: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4); + case 8: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node4); + case 9: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, node1, + node2, node3, node4); + case 10: + return nodeOf4x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node, node2, node3, node4); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node, node3, node4); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node, node4); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node, node1, node2, node3, node4); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node, node2, node3, node4); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node, node3, node4); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node, node4); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node2, node3, node4); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node2, node3, node4); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node2, node3, node4); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node3, node4); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node3, node4); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node3, node4); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node4); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node4); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node2, node4); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node3); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node3); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node2, node3); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map11To5Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + private Map11To5Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 27; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node5; + case 1: + return node4; + case 2: + return node3; + case 3: + return node2; + case 4: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4, node5); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 5; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 11; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 7: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 8: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, node1, node2, node3, node4, node5); + case 9: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, node1, node2, node3, node4, node5); + case 10: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf5x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4, node5); + case 1: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4, node5); + case 2: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4, node5); + case 3: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4, node5); + case 4: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + case 5: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + case 6: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + case 7: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + case 8: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + case 9: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node3, node4, node5); + case 10: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, node1, node2, node3, node4, node5); + case 11: + return nodeOf5x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf5x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 1: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 2: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 3: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 4: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 5: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 6: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 7: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 8: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node4, node5); + case 9: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, node1, + node2, node3, node4, node5); + case 10: + return nodeOf5x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node, node2, node3, node4, node5); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node, node3, node4, node5); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node, node4, node5); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node, node5); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node, node1, node2, node3, node4, node5); + case 1: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node, node2, node3, node4, node5); + case 2: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node, node3, node4, node5); + case 3: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node, node4, node5); + case 4: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node, node5); + case 5: + return nodeOf6x10(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4, node5); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4, node5); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4, node5); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node2, node3, node4, node5); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4, node5); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4, node5); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4, node5); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node2, node3, node4, node5); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node2, node3, node4, node5); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node2, node3, node4, node5); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node2, node3, node4, node5); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4, node5); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4, node5); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4, node5); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node3, node4, node5); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4, node5); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4, node5); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4, node5); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node3, node4, node5); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node3, node4, node5); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node3, node4, node5); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node3, node4, node5); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4, node5); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4, node5); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4, node5); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node4, node5); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4, node5); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4, node5); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4, node5); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node4, node5); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node4, node5); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node4, node5); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node2, node4, node5); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node5); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node5); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node5); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node5); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node5); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node5); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node5); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node5); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node5); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node3, node5); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node2, node3, node5); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node4); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node4); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node4); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, node1, node2, node3, node4); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, node1, node2, node3, node4); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, node1, node2, node3, node4); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, node1, node2, node3, node4); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map12To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + + private Map12To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 24; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 12; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 1: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 2: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 3: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 4: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 5: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 6: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + case 7: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12); + case 8: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12); + case 9: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12); + case 10: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12); + case 11: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12); + case 1: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12); + case 2: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12); + case 3: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12); + case 4: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 5: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 6: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 7: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 8: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12); + case 9: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12); + case 10: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12); + case 11: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12); + case 12: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 1: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 2: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 3: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 4: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 5: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 6: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12); + case 7: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12); + case 8: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12); + case 9: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12); + case 10: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12); + case 11: + return nodeOf0x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map12To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final CompactMapNode node1; + + private Map12To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 25; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 12; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 1: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 2: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 3: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 4: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 5: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 6: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 7: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + case 8: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, node1); + case 9: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, node1); + case 10: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, node1); + case 11: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1); + case 1: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1); + case 2: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1); + case 3: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1); + case 4: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 5: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 6: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 7: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 8: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 9: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1); + case 10: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, node1); + case 11: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, node1); + case 12: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 1: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 2: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 3: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 4: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 5: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 6: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 7: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1); + case 8: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1); + case 9: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, node1); + case 10: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, node1); + case 11: + return nodeOf1x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node, node1); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12); + case 1: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12); + case 2: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12); + case 3: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12); + case 4: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 5: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 6: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 7: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12); + case 8: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12); + case 9: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12); + case 10: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12); + case 11: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12); + case 12: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map12To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map12To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 26; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 12; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 2: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 3: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 4: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 5: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 6: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 7: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + case 8: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, node1, node2); + case 9: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, node1, node2); + case 10: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, node1, node2); + case 11: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2); + case 2: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2); + case 3: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2); + case 4: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 5: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 6: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 7: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 8: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 9: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node2); + case 10: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, node1, node2); + case 11: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, node1, node2); + case 12: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 1: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 2: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 3: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 4: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 5: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 6: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 7: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2); + case 8: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2); + case 9: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, node1, node2); + case 10: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, node1, node2); + case 11: + return nodeOf2x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node, node2); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node, node1, node2); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node, node2); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2); + case 1: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2); + case 2: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2); + case 3: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2); + case 4: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2); + case 5: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2); + case 6: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2); + case 7: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2); + case 8: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node2); + case 9: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node2); + case 10: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node2); + case 11: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node2); + case 12: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1); + case 1: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1); + case 2: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1); + case 3: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1); + case 4: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 5: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 6: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 7: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 8: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1); + case 9: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1); + case 10: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node1); + case 11: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node1); + case 12: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map12To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map12To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 27; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 12; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, node1, node2, node3); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, node1, node2, node3); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3); + case 3: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3); + case 4: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 5: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 6: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 7: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 8: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 9: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 10: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, node1, node2, node3); + case 11: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, node1, node2, node3); + case 12: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 1: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 2: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 3: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 4: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 5: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 6: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 7: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 8: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node3); + case 9: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, node1, node2, node3); + case 10: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, node1, node2, node3); + case 11: + return nodeOf3x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node, node2, node3); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node, node3); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node, node1, node2, node3); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node, node2, node3); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node, node3); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3); + case 2: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3); + case 3: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3); + case 4: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3); + case 5: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3); + case 6: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3); + case 7: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3); + case 8: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3); + case 9: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node2, node3); + case 10: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node2, node3); + case 11: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node2, node3); + case 12: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3); + case 2: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3); + case 3: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3); + case 4: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3); + case 5: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3); + case 6: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3); + case 7: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3); + case 8: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3); + case 9: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node3); + case 10: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node1, node3); + case 11: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node1, node3); + case 12: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2); + case 2: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2); + case 3: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2); + case 4: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 5: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 6: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 7: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 8: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2); + case 9: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node2); + case 10: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node1, node2); + case 11: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node1, node2); + case 12: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map12To4Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + private Map12To4Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 28; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node4; + case 1: + return node3; + case 2: + return node2; + case 3: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3, node4); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 4; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 12; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 4: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 5: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 6: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 7: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 8: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node4); + case 9: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, node1, node2, node3, node4); + case 10: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, node1, node2, node3, node4); + case 11: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf4x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3, node4); + case 1: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3, node4); + case 2: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3, node4); + case 3: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3, node4); + case 4: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + case 5: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + case 6: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + case 7: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + case 8: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + case 9: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node2, node3, node4); + case 10: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, node1, node2, node3, node4); + case 11: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, node1, node2, node3, node4); + case 12: + return nodeOf4x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf4x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 1: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 2: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 3: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 4: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 5: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 6: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 7: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 8: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4); + case 9: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, node1, node2, node3, node4); + case 10: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, node1, node2, node3, node4); + case 11: + return nodeOf4x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node, node2, node3, node4); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node, node3, node4); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node, node4); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node, node1, node2, node3, node4); + case 1: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node, node2, node3, node4); + case 2: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node, node3, node4); + case 3: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node, node4); + case 4: + return nodeOf5x11(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3, node4); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3, node4); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3, node4); + case 3: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node2, node3, node4); + case 4: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3, node4); + case 5: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3, node4); + case 6: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3, node4); + case 7: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3, node4); + case 8: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node2, node3, node4); + case 9: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node2, node3, node4); + case 10: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node2, node3, node4); + case 11: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node2, node3, node4); + case 12: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3, node4); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3, node4); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3, node4); + case 3: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node3, node4); + case 4: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3, node4); + case 5: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3, node4); + case 6: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3, node4); + case 7: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3, node4); + case 8: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node3, node4); + case 9: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node3, node4); + case 10: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node1, node3, node4); + case 11: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node1, node3, node4); + case 12: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node4); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node4); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node4); + case 3: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node4); + case 4: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node4); + case 5: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node4); + case 6: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node4); + case 7: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node4); + case 8: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node4); + case 9: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node2, node4); + case 10: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node1, node2, node4); + case 11: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node1, node2, node4); + case 12: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node3); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node3); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node3); + case 3: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, node1, node2, node3); + case 4: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 5: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 6: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 7: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 8: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 9: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, node1, node2, node3); + case 10: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, node1, node2, node3); + case 11: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, node1, node2, node3); + case 12: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map13To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + + private Map13To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 26; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 13; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 1: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 2: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 3: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 4: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 5: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 6: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 7: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + case 8: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13); + case 9: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13); + case 10: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13); + case 11: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13); + case 12: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13); + case 1: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13); + case 2: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13); + case 3: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13); + case 4: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 5: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 6: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 7: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 8: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 9: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13); + case 10: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13); + case 11: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13); + case 12: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13); + case 13: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 1: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 2: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 3: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 4: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 5: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 6: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 7: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13); + case 8: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13); + case 9: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13); + case 10: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13); + case 11: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13); + case 12: + return nodeOf0x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map13To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final CompactMapNode node1; + + private Map13To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 27; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 13; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 1: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 2: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 3: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 4: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 5: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 6: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 7: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 8: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + case 9: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, node1); + case 10: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, node1); + case 11: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, node1); + case 12: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1); + case 1: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1); + case 2: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1); + case 3: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1); + case 4: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 5: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 6: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 7: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 8: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 9: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 10: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, node1); + case 11: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, node1); + case 12: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, node1); + case 13: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 1: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 2: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 3: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 4: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 5: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 6: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 7: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 8: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1); + case 9: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, node1); + case 10: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, node1); + case 11: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, node1); + case 12: + return nodeOf1x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node, node1); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13); + case 1: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13); + case 2: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13); + case 3: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13); + case 4: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 5: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 6: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 7: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 8: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13); + case 9: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13); + case 10: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13); + case 11: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13); + case 12: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13); + case 13: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map13To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map13To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 28; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 13; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 2: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 3: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 4: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 5: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 6: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 7: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 8: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + case 9: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, node1, node2); + case 10: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, node1, node2); + case 11: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, node1, node2); + case 12: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2); + case 2: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2); + case 3: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2); + case 4: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 5: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 6: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 7: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 8: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 9: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 10: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, node1, node2); + case 11: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, node1, node2); + case 12: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, node1, node2); + case 13: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 1: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 2: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 3: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 4: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 5: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 6: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 7: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 8: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2); + case 9: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, node1, node2); + case 10: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, node1, node2); + case 11: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, node1, node2); + case 12: + return nodeOf2x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node, node2); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node, node1, node2); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node, node2); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2); + case 1: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2); + case 2: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2); + case 3: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2); + case 4: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2); + case 5: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2); + case 6: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2); + case 7: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2); + case 8: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2); + case 9: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node2); + case 10: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, node2); + case 11: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, node2); + case 12: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, node2); + case 13: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1); + case 1: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1); + case 2: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1); + case 3: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1); + case 4: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 5: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 6: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 7: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 8: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 9: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node1); + case 10: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, node1); + case 11: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, node1); + case 12: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, node1); + case 13: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map13To3Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + private Map13To3Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 29; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node3; + case 1: + return node2; + case 2: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2, node3); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 3; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 13; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 3: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 4: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 5: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 6: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 7: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 8: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 9: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, node1, node2, node3); + case 10: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, node1, node2, node3); + case 11: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, node1, node2, node3); + case 12: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf3x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 1: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 2: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 3: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 4: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 5: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 6: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 7: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 8: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 9: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 10: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, node1, node2, node3); + case 11: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, node1, node2, node3); + case 12: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, node1, node2, node3); + case 13: + return nodeOf3x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf3x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 1: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 2: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 3: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 4: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 5: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 6: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 7: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 8: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3); + case 9: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, node1, node2, node3); + case 10: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, node1, node2, node3); + case 11: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, node1, node2, node3); + case 12: + return nodeOf3x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node, node2, node3); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node, node3); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node, node1, node2, node3); + case 1: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node, node2, node3); + case 2: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node, node3); + case 3: + return nodeOf4x12(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 2: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 3: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 4: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 5: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 6: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 7: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 8: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 9: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node2, node3); + case 10: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, node2, node3); + case 11: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, node2, node3); + case 12: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, node2, node3); + case 13: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 2: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 3: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 4: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 5: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 6: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 7: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 8: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 9: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node3); + case 10: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, node1, node3); + case 11: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, node1, node3); + case 12: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, node1, node3); + case 13: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 2: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 3: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 4: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 5: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 6: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 7: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 8: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 9: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, node1, node2); + case 10: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, node1, node2); + case 11: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, node1, node2); + case 12: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, node1, node2); + case 13: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map14To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + + private Map14To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 28; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + case 13: + return key14; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + case 13: + return val14; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + case 13: + return (java.util.Map.Entry) entryOf(key14, val14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 14; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 1: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 2: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 3: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 4: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 5: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 6: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 7: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 8: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + case 9: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, key14, val14); + case 10: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, key14, val14); + case 11: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, key14, val14); + case 12: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, key14, val14); + case 13: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x15(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14); + case 1: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14); + case 2: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14); + case 3: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14); + case 4: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 5: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 6: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 7: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 8: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 9: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 10: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, key14, val14); + case 11: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, key14, val14); + case 12: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, key14, val14); + case 13: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, key14, val14); + case 14: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 1: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 2: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 3: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 4: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 5: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 6: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 7: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 8: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14); + case 9: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, key14, val14); + case 10: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, key14, val14); + case 11: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, key14, val14); + case 12: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key14, val14); + case 13: + return nodeOf0x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (idxNew) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map14To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final CompactMapNode node1; + + private Map14To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 29; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + case 13: + return key14; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + case 13: + return val14; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + case 13: + return (java.util.Map.Entry) entryOf(key14, val14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 14; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 1: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 2: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 3: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 4: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 5: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 6: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 7: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 8: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 9: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + case 10: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, key14, val14, node1); + case 11: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, key14, val14, node1); + case 12: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, key14, val14, node1); + case 13: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 1: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 2: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 3: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 4: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 5: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 6: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 7: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 8: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 9: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 10: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 11: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, key14, val14, node1); + case 12: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, key14, val14, node1); + case 13: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, key14, val14, node1); + case 14: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 1: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 2: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 3: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 4: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 5: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 6: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 7: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 8: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1); + case 9: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, key14, val14, node1); + case 10: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, key14, val14, node1); + case 11: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, key14, val14, node1); + case 12: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key14, val14, node1); + case 13: + return nodeOf1x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (idxNew) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node, node1); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x15(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 1: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 2: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 3: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 4: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 5: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 6: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 7: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 8: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 9: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14); + case 10: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, key14, val14); + case 11: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, key14, val14); + case 12: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, key14, val14); + case 13: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, key14, val14); + case 14: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map14To2Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final CompactMapNode node1; + private final CompactMapNode node2; + + private Map14To2Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.node1 = node1; + this.node2 = node2; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 30; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + case 13: + return key14; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + case 13: + return val14; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + case 13: + return (java.util.Map.Entry) entryOf(key14, val14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node2; + case 1: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1, node2); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 2; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 14; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 2: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 3: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 4: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 5: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 6: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 7: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 8: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 9: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 10: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, key14, val14, node1, node2); + case 11: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, key14, val14, node1, node2); + case 12: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, key14, val14, node1, node2); + case 13: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf2x15(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 1: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 2: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 3: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 4: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 5: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 6: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 7: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 8: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 9: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 10: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, key14, val14, node1, node2); + case 11: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, key14, val14, node1, node2); + case 12: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, key14, val14, node1, node2); + case 13: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, key14, val14, node1, node2); + case 14: + return nodeOf2x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf2x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 1: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 2: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 3: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 4: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 5: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 6: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 7: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 8: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2); + case 9: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, key14, val14, node1, node2); + case 10: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, key14, val14, node1, node2); + case 11: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, key14, val14, node1, node2); + case 12: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key14, val14, node1, node2); + case 13: + return nodeOf2x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node, node2); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (idxNew) { + case 0: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node, node1, node2); + case 1: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node, node2); + case 2: + return nodeOf3x13(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 1: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 2: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 3: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 4: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 5: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 6: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 7: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 8: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 9: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 10: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, key14, val14, node2); + case 11: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, key14, val14, node2); + case 12: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, key14, val14, node2); + case 13: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, key14, val14, node2); + case 14: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 1: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 2: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 3: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 4: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 5: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 6: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 7: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 8: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 9: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 10: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, key14, val14, node1); + case 11: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, key14, val14, node1); + case 12: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, key14, val14, node1); + case 13: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, key14, val14, node1); + case 14: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map15To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + + private Map15To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 30; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + case 13: + return key14; + case 14: + return key15; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + case 13: + return val14; + case 14: + return val15; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + case 13: + return (java.util.Map.Entry) entryOf(key14, val14); + case 14: + return (java.util.Map.Entry) entryOf(key15, val15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 15; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 1: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 2: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 3: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 4: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 5: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 6: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 7: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 8: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 9: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 10: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, key14, val14, key15, val15); + case 11: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, key14, val14, key15, val15); + case 12: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, key14, val14, key15, val15); + case 13: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val, key15, val15); + case 14: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x16(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 1: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 2: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 3: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 4: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 5: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 6: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 7: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 8: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 9: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 10: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 11: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, key14, val14, key15, val15); + case 12: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, key14, val14, key15, val15); + case 13: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, key14, val14, key15, val15); + case 14: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key, val, key15, val15); + case 15: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x14(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 1: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 2: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 3: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 4: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 5: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 6: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 7: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 8: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15); + case 9: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, key14, val14, key15, val15); + case 10: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, key14, val14, key15, val15); + case 11: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, key14, val14, key15, val15); + case 12: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key14, val14, key15, val15); + case 13: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key15, val15); + case 14: + return nodeOf0x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 14: + switch (idxNew) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + + private static final class Map15To1Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final CompactMapNode node1; + + private Map15To1Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.node1 = node1; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 31; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + case 13: + return key14; + case 14: + return key15; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + case 13: + return val14; + case 14: + return val15; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + case 13: + return (java.util.Map.Entry) entryOf(key14, val14); + case 14: + return (java.util.Map.Entry) entryOf(key15, val15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + Iterator nodeIterator() { + return ArrayIterator.of(node1); + } + + boolean hasNodes() { + return true; + } + + int nodeArity() { + return 1; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 15; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 1: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 2: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 3: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 4: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 5: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 6: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 7: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 8: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 9: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 10: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 11: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, key14, val14, key15, val15, node1); + case 12: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, key14, val14, key15, val15, node1); + case 13: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val, key15, val15, node1); + case 14: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf1x16(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 1: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 2: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 3: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 4: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 5: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 6: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 7: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 8: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 9: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 10: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 11: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 12: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, key14, val14, key15, val15, node1); + case 13: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, key14, val14, key15, val15, node1); + case 14: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key, val, key15, val15, node1); + case 15: + return nodeOf1x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf1x14(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 1: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 2: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 3: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 4: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 5: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 6: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 7: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 8: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1); + case 9: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, key14, val14, key15, val15, node1); + case 10: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, key14, val14, key15, val15, node1); + case 11: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, key14, val14, key15, val15, node1); + case 12: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key14, val14, key15, val15, node1); + case 13: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key15, val15, node1); + case 14: + return nodeOf1x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key15, val15, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key15, val15, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 14: + switch (idxNew) { + case 0: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node, node1); + case 1: + return nodeOf2x14(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf0x16(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, + val15); + case 1: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, + val15); + case 2: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, + val15); + case 3: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, + key10, val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, + val15); + case 4: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 5: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 6: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 7: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 8: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 9: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 10: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key, val, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15); + case 11: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key, val, key12, val12, key13, val13, key14, val14, key15, val15); + case 12: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key, val, key13, val13, key14, val14, key15, val15); + case 13: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key, val, key14, val14, key15, val15); + case 14: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key, val, key15, val15); + case 15: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + } + + private static final class Map16To0Node_5Bits_Spec0To16_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + private final int key9; + private final int val9; + private final int key10; + private final int val10; + private final int key11; + private final int val11; + private final int key12; + private final int val12; + private final int key13; + private final int val13; + private final int key14; + private final int val14; + private final int key15; + private final int val15; + private final int key16; + private final int val16; + + private Map16To0Node_5Bits_Spec0To16_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8, final int key9, final int val9, + final int key10, final int val10, final int key11, final int val11, final int key12, + final int val12, final int key13, final int val13, final int key14, final int val14, + final int key15, final int val15, final int key16, final int val16) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + this.key9 = key9; + this.val9 = val9; + this.key10 = key10; + this.val10 = val10; + this.key11 = key11; + this.val11 = val11; + this.key12 = key12; + this.val12 = val12; + this.key13 = key13; + this.val13 = val13; + this.key14 = key14; + this.val14 = val14; + this.key15 = key15; + this.val15 = val15; + this.key16 = key16; + this.val16 = val16; + } + + boolean hasSlots() { + return true; + } + + int slotArity() { + return 32; + } + + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + int getKey(final int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + case 8: + return key9; + case 9: + return key10; + case 10: + return key11; + case 11: + return key12; + case 12: + return key13; + case 13: + return key14; + case 14: + return key15; + case 15: + return key16; + default: + throw new IllegalStateException("Index out of range."); + } + } + + int getValue(final int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + case 8: + return val9; + case 9: + return val10; + case 10: + return val11; + case 11: + return val12; + case 12: + return val13; + case 13: + return val14; + case 14: + return val15; + case 15: + return val16; + default: + throw new IllegalStateException("Index out of range."); + } + } + + java.util.Map.Entry getKeyValueEntry(final int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + case 8: + return (java.util.Map.Entry) entryOf(key9, val9); + case 9: + return (java.util.Map.Entry) entryOf(key10, val10); + case 10: + return (java.util.Map.Entry) entryOf(key11, val11); + case 11: + return (java.util.Map.Entry) entryOf(key12, val12); + case 12: + return (java.util.Map.Entry) entryOf(key13, val13); + case 13: + return (java.util.Map.Entry) entryOf(key14, val14); + case 14: + return (java.util.Map.Entry) entryOf(key15, val15); + case 15: + return (java.util.Map.Entry) entryOf(key16, val16); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode getNode(final int index) { + throw new IllegalStateException("Index out of range."); + } + + Iterator nodeIterator() { + return Collections.emptyIterator(); + } + + boolean hasNodes() { + return false; + } + + int nodeArity() { + return 0; + } + + boolean hasPayload() { + return true; + } + + int payloadArity() { + return 16; + } + + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = nodeMap(); + final int dataMap = dataMap(); + + switch (idx) { + case 0: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 1: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 2: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 3: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 4: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 5: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 6: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 7: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 8: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 9: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 10: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 11: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val, key13, val13, key14, val14, key15, val15, key16, val16); + case 12: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val, key14, val14, key15, val15, key16, val16); + case 13: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val, key15, val15, key16, val16); + case 14: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val, key16, val16); + case 15: + return nodeOf0x16(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = dataIndex(bitpos); + + // TODO: improve naming of bitmaps in heterogeneous + final int nodeMap = nodeMap(); + final int dataMap = dataMap() | bitpos; + + switch (idx) { + case 0: + return nodeOf0x17(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 1: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 2: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 3: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 4: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 5: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 6: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 7: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val, key8, val8, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 8: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key, val, key9, val9, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 9: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key, val, key10, + val10, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 10: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key, + val, key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 11: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key, val, key12, val12, key13, val13, key14, val14, key15, val15, key16, + val16); + case 12: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key, val, key13, val13, key14, val14, key15, val15, key16, + val16); + case 13: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key, val, key14, val14, key15, val15, key16, + val16); + case 14: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key, val, key15, val15, key16, + val16); + case 15: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key, val, key16, + val16); + case 16: + return nodeOf0x17(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, key, + val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf0x15(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 1: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 2: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 3: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 4: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 5: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 6: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 7: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 8: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 9: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, key12, + val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 10: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key12, + val12, key13, val13, key14, val14, key15, val15, key16, val16); + case 11: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key13, val13, key14, val14, key15, val15, key16, val16); + case 12: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key14, val14, key15, val15, key16, val16); + case 13: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key15, val15, key16, val16); + case 14: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key16, val16); + case 15: + return nodeOf0x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, + val11, key12, val12, key13, val13, key14, val14, key15, val15); + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int idxOld = dataIndex(bitpos); + final int idxNew = nodeIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (idxOld) { + case 0: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key9, val9, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 8: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key10, val10, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 9: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key11, val11, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 10: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key12, val12, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 11: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key13, val13, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 12: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key14, val14, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 13: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key15, val15, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 14: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key16, val16, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 15: + switch (idxNew) { + case 0: + return nodeOf1x15(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9, key10, val10, + key11, val11, key12, val12, key13, val13, key14, val14, key15, val15, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieMap_5Bits_Spec0To8.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieMap_5Bits_Spec0To8.java new file mode 100644 index 0000000..d257054 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieMap_5Bits_Spec0To8.java @@ -0,0 +1,21249 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.specialized; + +import java.text.DecimalFormat; +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.atomic.AtomicReference; + +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +public class TrieMap_5Bits_Spec0To8 implements + io.usethesource.capsule.Map.Immutable { + + private static final TrieMap_5Bits_Spec0To8 EMPTY_MAP = + new TrieMap_5Bits_Spec0To8(CompactMapNode.EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractMapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieMap_5Bits_Spec0To8(AbstractMapNode rootNode, int hashCode, int cachedSize) { + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final io.usethesource.capsule.Map.Immutable of() { + return TrieMap_5Bits_Spec0To8.EMPTY_MAP; + } + + public static final io.usethesource.capsule.Map.Immutable of( + Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + io.usethesource.capsule.Map.Immutable result = TrieMap_5Bits_Spec0To8.EMPTY_MAP; + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final K key = (K) keyValuePairs[i]; + final V val = (V) keyValuePairs[i + 1]; + + result = result.__put(key, val); + } + + return result; + } + + public static final io.usethesource.capsule.Map.Transient transientOf() { + return TrieMap_5Bits_Spec0To8.EMPTY_MAP.asTransient(); + } + + public static final io.usethesource.capsule.Map.Transient transientOf( + Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + final io.usethesource.capsule.Map.Transient result = TrieMap_5Bits_Spec0To8.EMPTY_MAP + .asTransient(); + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final K key = (K) keyValuePairs[i]; + final V val = (V) keyValuePairs[i + 1]; + + result.__put(key, val); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + @Override + public V get(final Object o) { + try { + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public V getEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public io.usethesource.capsule.Map.Immutable __put(final K key, final V val) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieMap_5Bits_Spec0To8(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val.hashCode(); + return new TrieMap_5Bits_Spec0To8(newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __putEquivalent(final K key, final V val, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = details.getReplacedValue().hashCode(); + final int valHashNew = val.hashCode(); + + return new TrieMap_5Bits_Spec0To8(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = val.hashCode(); + return new TrieMap_5Bits_Spec0To8(newRootNode, hashCode + ((keyHash ^ valHash)), + cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __putAll( + final Map map) { + final io.usethesource.capsule.Map.Transient tmpTransient = this.asTransient(); + tmpTransient.__putAll(map); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Map.Immutable __putAllEquivalent( + final Map map, + final Comparator cmp) { + final io.usethesource.capsule.Map.Transient tmpTransient = this.asTransient(); + tmpTransient.__putAllEquivalent(map, cmp); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Map.Immutable __remove(final K key) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieMap_5Bits_Spec0To8(newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Map.Immutable __removeEquivalent(final K key, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + return new TrieMap_5Bits_Spec0To8(newRootNode, hashCode - ((keyHash ^ valHash)), + cachedSize - 1); + } + + return this; + } + + @Override + public V put(final K key, final V val) { + throw new UnsupportedOperationException(); + } + + @Override + public void putAll(final Map m) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public V remove(final Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new MapKeyIterator<>(rootNode); + } + + @Override + public Iterator valueIterator() { + return new MapValueIterator<>(rootNode); + } + + @Override + public Iterator> entryIterator() { + return new MapEntryIterator<>(rootNode); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_Spec0To8.this.keyIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_Spec0To8.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Spec0To8.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Spec0To8.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_Spec0To8.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_Spec0To8.this.valueIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_Spec0To8.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Spec0To8.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Spec0To8.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TrieMap_5Bits_Spec0To8.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieMap_5Bits_Spec0To8.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Spec0To8.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Spec0To8.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_Spec0To8.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieMap_5Bits_Spec0To8) { + TrieMap_5Bits_Spec0To8 that = (TrieMap_5Bits_Spec0To8) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + final V val = (V) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public io.usethesource.capsule.Map.Transient asTransient() { + return new TransientTrieMap_5Bits_Spec0To8(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractMapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieMap_5Bits_Spec0To8NodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. Payload X Node + */ + protected int[][] arityCombinationsHistogram() { + final Iterator> it = nodeIterator(); + final int[][] sumArityCombinations = new int[33][33]; + + while (it.hasNext()) { + final AbstractMapNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[33]; + + final int maxArity = 32; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[33]; + for (int cumsum = 0, i = 0; i < 33; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 33; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + abstract static class Optional { + + private static final Optional EMPTY = new Optional() { + @Override + boolean isPresent() { + return false; + } + + @Override + Object get() { + return null; + } + }; + + static Optional empty() { + return EMPTY; + } + + static Optional of(T value) { + return new Value(value); + } + + abstract boolean isPresent(); + + abstract T get(); + + private static final class Value extends Optional { + + private final T value; + + private Value(T value) { + this.value = value; + } + + @Override + boolean isPresent() { + return true; + } + + @Override + T get() { + return value; + } + } + } + + static final class MapResult { + + private V replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(V replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static MapResult unchanged() { + return new MapResult<>(); + } + + private MapResult() { + } + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public V getReplacedValue() { + return replacedValue; + } + } + + protected static interface INode { + + } + + protected static abstract class AbstractMapNode implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final K key, final int keyHash, final int shift); + + abstract boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final K key, final int keyHash, final int shift); + + abstract Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract CompactMapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode updated(final AtomicReference mutator, final K key, + final V val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + abstract CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractMapNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractMapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractMapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract K getKey(final int index); + + abstract V getValue(final int index); + + abstract Map.Entry getKeyValueEntry(final int index); + + @Deprecated + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + int size() { + final Iterator it = new MapKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactMapNode extends AbstractMapNode { + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return (int) (1 << mask); + } + + abstract int nodeMap(); + + abstract int dataMap(); + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactMapNode getNode(final int index); + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactMapNode copyAndSetValue(final AtomicReference mutator, + final int bitpos, final V val); + + abstract CompactMapNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final K key, final V val); + + abstract CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos); + + abstract CompactMapNode copyAndSetNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromInlineToNode( + final AtomicReference mutator, final int bitpos, final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromNodeToInline( + final AtomicReference mutator, final int bitpos, final CompactMapNode node); + + CompactMapNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + static final CompactMapNode mergeTwoKeyValPairs(final K key0, final V val0, + final int keyHash0, final K key1, final V val1, final int keyHash1, final int shift) { + assert !(key0.equals(key1)); + + if (shift >= HASH_CODE_LENGTH) { + // throw new + // IllegalStateException("Hash collision not yet fixed."); + return new HashCollisionMapNode_5Bits_Spec0To8<>(keyHash0, (K[]) new Object[]{key0, key1}, + (V[]) new Object[]{val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int dataMap = (int) (bitpos(mask0) | bitpos(mask1)); + + if (mask0 < mask1) { + return nodeOf(null, (int) 0, dataMap, key0, val0, key1, val1); + } else { + return nodeOf(null, (int) 0, dataMap, key1, val1, key0, val0); + } + } else { + final CompactMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, + keyHash1, shift + BIT_PARTITION_SIZE); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf(null, nodeMap, (int) 0, node); + } + } + + static final CompactMapNode EMPTY_NODE; + + static { + + EMPTY_NODE = new Map0To0Node_5Bits_Spec0To8<>(null, (int) 0, (int) 0); + + } + + ; + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object[] nodes) { + return new BitmapIndexedMapNode<>(mutator, nodeMap, dataMap, nodes); + } + + static final CompactMapNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap) { + return EMPTY_NODE; + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1) { + return new Map0To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map0To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map0To3Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map0To4Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map0To5Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2, node3, node4, + node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map0To6Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2, node3, node4, + node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map0To7Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2, node3, node4, + node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + return new Map0To8Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2, node3, node4, + node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8, final CompactMapNode node9) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1) { + return new Map1To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1) { + return new Map1To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map1To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map1To3Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map1To4Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map1To5Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map1To6Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + return new Map1To7Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, node1, node2, + node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, val1, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2) { + return new Map2To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1) { + return new Map2To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2) { + return new Map2To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map2To3Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map2To4Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map2To5Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map2To6Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, val1, key2, val2, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3) { + return new Map3To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1) { + return new Map3To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map3To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map3To3Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map3To4Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map3To5Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[]{key1, val1, key2, val2, key3, val3, + node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4) { + return new Map4To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1) { + return new Map4To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map4To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map4To3Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map4To4Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[]{key1, val1, key2, val2, key3, val3, + key4, val4, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5) { + return new Map5To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1) { + return new Map5To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2) { + return new Map5To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map5To3Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[]{key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6) { + return new Map6To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1) { + return new Map6To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map6To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[]{key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7) { + return new Map7To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1) { + return new Map7To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, + final CompactMapNode node1, final CompactMapNode node2) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[]{key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8) { + return new Map8To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, val1, key2, val2, + key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final CompactMapNode node1) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[]{key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final V val1, final K key2, + final V val2, final K key3, final V val3, final K key4, final V val4, final K key5, + final V val5, final K key6, final V val6, final K key7, final V val7, final K key8, + final V val8, final K key9, final V val9) { + return nodeOf(mutator, nodeMap, dataMap, new Object[]{key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9}); + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + CompactMapNode nodeAt(final int bitpos) { + return getNode(nodeIndex(bitpos)); + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index).equals(key); + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return false; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return cmp.compare(getKey(index), key) == 0; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index).equals(key)) { + final V result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (cmp.compare(getKey(index), key) == 0) { + final V result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return Optional.empty(); + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (currentKey.equals(key)) { + final V currentVal = getValue(dataIndex); + + if (currentVal.equals(val)) { + return this; + } else { + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } + } else { + final V currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (cmp.compare(currentKey, key) == 0) { + final V currentVal = getValue(dataIndex); + + if (cmp.compare(currentVal, val) == 0) { + return this; + } else { + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } + } else { + final V currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = + mergeTwoKeyValPairs(currentKey, currentVal, transformHashCode(currentKey.hashCode()), + key, val, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex).equals(key)) { + final V currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(1), + getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(0), + getValue(0)); + } + } else if (this.arity() == 9) { + return removeInplaceValueAndConvertToSpecializedNode(mutator, bitpos); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + details.modified(); + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (cmp.compare(getKey(dataIndex), key) == 0) { + final V currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(1), + getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(0), + getValue(0)); + } + } else if (this.arity() == 9) { + return removeInplaceValueAndConvertToSpecializedNode(mutator, bitpos); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + details.modified(); + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = (int) (map >> 1); + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getKey(i)), + Objects.hashCode(getValue(i)))); + + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedMapNode extends CompactMapNode { + + private final int nodeMap; + private final int dataMap; + + CompactMixedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + protected static abstract class CompactNodesOnlyMapNode extends CompactMapNode { + + private final int nodeMap; + + CompactNodesOnlyMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return 0; + } + + } + + protected static abstract class CompactValuesOnlyMapNode extends CompactMapNode { + + private final int dataMap; + + CompactValuesOnlyMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return 0; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + protected static abstract class CompactEmptyMapNode extends CompactMapNode { + + CompactEmptyMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + } + + @Override + public int nodeMap() { + return 0; + } + + @Override + public int dataMap() { + return 0; + } + + } + + private static final class BitmapIndexedMapNode extends CompactMixedMapNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + super(mutator, nodeMap, dataMap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + + assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < TUPLE_LENGTH * payloadArity(); i++) { + assert ((nodes[i] instanceof CompactMapNode) == false); + } + for (int i = TUPLE_LENGTH * payloadArity(); i < nodes.length; i++) { + assert ((nodes[i] instanceof CompactMapNode) == true); + } + } + + assert arity() > 8; + assert nodeInvariant(); + } + + @Override + K getKey(final int index) { + return (K) nodes[TUPLE_LENGTH * index]; + } + + @Override + V getValue(final int index) { + return (V) nodes[TUPLE_LENGTH * index + 1]; + } + + @Override + Map.Entry getKeyValueEntry(final int index) { + return entryOf((K) nodes[TUPLE_LENGTH * index], (V) nodes[TUPLE_LENGTH * index + 1]); + } + + @Override + CompactMapNode getNode(final int index) { + return (CompactMapNode) nodes[nodes.length - 1 - index]; + } + + @Override + boolean hasPayload() { + return dataMap() != 0; + } + + @Override + int payloadArity() { + return java.lang.Integer.bitCount(dataMap()); + } + + @Override + boolean hasNodes() { + return nodeMap() != 0; + } + + @Override + int nodeArity() { + return java.lang.Integer.bitCount(nodeMap()); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + ((int) dataMap()); + result = prime * result + ((int) dataMap()); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedMapNode that = (BitmapIndexedMapNode) other; + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + if (!Arrays.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos) + 1; + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = val; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(bitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = val; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + return nodeOf(mutator, nodeMap(), (int) (dataMap() | bitpos), dst); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + return nodeOf(mutator, nodeMap(), (int) (dataMap() ^ bitpos), dst); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2 + 1]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 2, dst, idxNew + 1, src.length - idxNew - 2); + + return nodeOf(mutator, (int) (nodeMap() | bitpos), (int) (dataMap() ^ bitpos), dst); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 2]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = node.getKey(0); + dst[idxNew + 1] = node.getValue(0); + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 2, src.length - idxOld - 1); + + return nodeOf(mutator, (int) (nodeMap() ^ bitpos), (int) (dataMap() | bitpos), dst); + } + + @Override + CompactMapNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (payloadArity()) { // 0 <= payloadArity <= 9 // or ts.nMax + case 1: { + + switch (valIndex) { + case 0: { + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node7, + node8); + + } + case 2: { + K key1; + V val1; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7); + + } + case 3: { + K key1; + V val1; + K key2; + V val2; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6); + + } + case 4: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node3, node4, node5); + + } + case 5: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4); + + } + case 6: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3); + + } + case 7: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2); + + } + case 8: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + K key7; + V val7; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + + } + case 9: { + K key1; + V val1; + K key2; + V val2; + K key3; + V val3; + K key4; + V val4; + K key5; + V val5; + K key6; + V val6; + K key7; + V val7; + K key8; + V val8; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + + } + default: + throw new IllegalStateException("Index out of range."); + } + } + } + + private static final class HashCollisionMapNode_5Bits_Spec0To8 + extends CompactMapNode { + + private final K[] keys; + private final V[] vals; + private final int hash; + + HashCollisionMapNode_5Bits_Spec0To8(final int hash, final K[] keys, final V[] vals) { + this.keys = keys; + this.vals = vals; + this.hash = hash; + + assert payloadArity() >= 2; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (K k : keys) { + if (k.equals(key)) { + return true; + } + } + } + return false; + } + + @Override + boolean containsKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (K k : keys) { + if (cmp.compare(k, key) == 0) { + return true; + } + } + } + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (key.equals(_key)) { + final V val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (cmp.compare(key, _key) == 0) { + final V val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final V currentVal = vals[idx]; + + if (currentVal.equals(val)) { + return this; + } else { + // add new mapping + final V[] src = this.vals; + final V[] dst = (V[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode_5Bits_Spec0To8<>(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final V[] valsNew = (V[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits_Spec0To8<>(keyHash, keysNew, valsNew); + } + + @Override + CompactMapNode updated(final AtomicReference mutator, final K key, final V val, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final V currentVal = vals[idx]; + + if (cmp.compare(currentVal, val) == 0) { + return this; + } else { + // add new mapping + final V[] src = this.vals; + final V[] dst = (V[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode_5Bits_Spec0To8<>(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final V[] valsNew = (V[]) new Object[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits_Spec0To8<>(keyHash, keysNew, valsNew); + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + final V currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final V theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details); + } else { + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final V[] valsNew = (V[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits_Spec0To8<>(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + @Override + CompactMapNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final MapResult details, + final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + final V currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final V theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details, cmp); + } else { + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final V[] valsNew = (V[]) new Object[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits_Spec0To8<>(keyHash, keysNew, valsNew); + } + } + } + return this; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return keys.length; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + int arity() { + return payloadArity(); + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + K getKey(final int index) { + return keys[index]; + } + + @Override + V getValue(final int index) { + return vals[index]; + } + + @Override + Map.Entry getKeyValueEntry(final int index) { + return entryOf(keys[index], vals[index]); + } + + @Override + public CompactMapNode getNode(int index) { + throw new IllegalStateException("Is leaf node."); + } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + hash; + result = prime * result + Arrays.hashCode(keys); + result = prime * result + Arrays.hashCode(vals); + return result; + } + + @Override + public boolean equals(Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + HashCollisionMapNode_5Bits_Spec0To8 that = + (HashCollisionMapNode_5Bits_Spec0To8) other; + + if (hash != that.hash) { + return false; + } + + if (arity() != that.arity()) { + return false; + } + + /* + * Linear scan for each key, because of arbitrary element order. + */ + outerLoop: + for (int i = 0; i < that.payloadArity(); i++) { + final Object otherKey = that.getKey(i); + final Object otherVal = that.getValue(i); + + for (int j = 0; j < keys.length; j++) { + final K key = keys[j]; + final V val = vals[j]; + + if (key.equals(otherKey) && val.equals(otherVal)) { + continue outerLoop; + } + } + return false; + } + + return true; + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final V val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key, final V val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + int nodeMap() { + throw new UnsupportedOperationException(); + } + + @Override + int dataMap() { + throw new UnsupportedOperationException(); + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractMapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractMapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractMapNode[] nodes = new AbstractMapNode[MAX_DEPTH]; + + AbstractMapIterator(AbstractMapNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractMapNode nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class MapKeyIterator extends AbstractMapIterator + implements Iterator { + + MapKeyIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + protected static class MapValueIterator extends AbstractMapIterator + implements Iterator { + + MapValueIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public V next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getValue(currentValueCursor++); + } + } + + } + + protected static class MapEntryIterator extends AbstractMapIterator + implements Iterator> { + + MapEntryIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKeyValueEntry(currentValueCursor++); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieMap_5Bits_Spec0To8NodeIterator + implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieMap_5Bits_Spec0To8NodeIterator(AbstractMapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractMapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieMap_5Bits_Spec0To8 implements + io.usethesource.capsule.Map.Transient { + + final private AtomicReference mutator; + private AbstractMapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieMap_5Bits_Spec0To8(TrieMap_5Bits_Spec0To8 trieMap_5Bits_Spec0To8) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieMap_5Bits_Spec0To8.rootNode; + this.hashCode = trieMap_5Bits_Spec0To8.hashCode; + this.cachedSize = trieMap_5Bits_Spec0To8.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it.hasNext(); ) { + final Map.Entry entry = it.next(); + final K key = entry.getKey(); + final V val = entry.getValue(); + + hash += key.hashCode() ^ val.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public V put(final K key, final V val) { + throw new UnsupportedOperationException(); + } + + @Override + public void putAll(final Map m) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public V remove(final Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean containsKey(final Object o) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + return rootNode.containsKey(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + @Override + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext(); ) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + @Override + public V get(final Object o) { + try { + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public V getEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public V __put(final K key, final V val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final V old = details.getReplacedValue(); + + final int valHashOld = old.hashCode(); + final int valHashNew = val.hashCode(); + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } else { + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + @Override + public V __putEquivalent(final K key, final V val, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final V old = details.getReplacedValue(); + + final int valHashOld = old.hashCode(); + final int valHashNew = val.hashCode(); + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } else { + final int valHashNew = val.hashCode(); + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + @Override + public boolean __putAll(final Map map) { + boolean modified = false; + + for (Map.Entry entry : map.entrySet()) { + final boolean isPresent = this.containsKey(entry.getKey()); + final V replaced = this.__put(entry.getKey(), entry.getValue()); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + @Override + public boolean __putAllEquivalent(final Map map, + final Comparator cmp) { + boolean modified = false; + + for (Map.Entry entry : map.entrySet()) { + final boolean isPresent = this.containsKeyEquivalent(entry.getKey(), cmp); + final V replaced = this.__putEquivalent(entry.getKey(), entry.getValue(), cmp); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + @Override + public V __remove(final K key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + @Override + public V __removeEquivalent(final K key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = details.getReplacedValue().hashCode(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator keyIterator() { + return new TransientMapKeyIterator<>(this); + } + + @Override + public Iterator valueIterator() { + return new TransientMapValueIterator<>(this); + } + + @Override + public Iterator> entryIterator() { + return new TransientMapEntryIterator<>(this); + } + + public static class TransientMapKeyIterator extends MapKeyIterator { + + final TransientTrieMap_5Bits_Spec0To8 collection; + K lastKey; + + public TransientMapKeyIterator(final TransientTrieMap_5Bits_Spec0To8 collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(lastKey); + } + } + + public static class TransientMapValueIterator extends MapValueIterator { + + final TransientTrieMap_5Bits_Spec0To8 collection; + + public TransientMapValueIterator(final TransientTrieMap_5Bits_Spec0To8 collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public V next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientMapEntryIterator extends MapEntryIterator { + + final TransientTrieMap_5Bits_Spec0To8 collection; + + public TransientMapEntryIterator(final TransientTrieMap_5Bits_Spec0To8 collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public Map.Entry next() { + return super.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits_Spec0To8.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Spec0To8.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Spec0To8.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Spec0To8.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits_Spec0To8.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits_Spec0To8.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Spec0To8.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Spec0To8.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Spec0To8.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieMap_5Bits_Spec0To8.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Spec0To8.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Spec0To8.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Spec0To8.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits_Spec0To8.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieMap_5Bits_Spec0To8) { + TransientTrieMap_5Bits_Spec0To8 that = (TransientTrieMap_5Bits_Spec0To8) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) { + return false; + } + + for ( + Iterator it = that.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + + try { + final K key = (K) entry.getKey(); + final Optional result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (!result.isPresent()) { + return false; + } else { + final V val = (V) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public io.usethesource.capsule.Map.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieMap_5Bits_Spec0To8(rootNode, hashCode, cachedSize); + } + } + + private static final class Map0To0Node_5Bits_Spec0To8 extends CompactEmptyMapNode { + + Map0To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + super(mutator, nodeMap, dataMap); + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return false; + } + + @Override + int slotArity() { + return 0; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + V getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_EMPTY; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + int result = 1; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + return true; + } + + } + + private static final class Map0To1Node_5Bits_Spec0To8 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + + Map0To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 1; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + V getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To1Node_5Bits_Spec0To8 that = (Map0To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map0To2Node_5Bits_Spec0To8 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map0To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 2; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + V getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To2Node_5Bits_Spec0To8 that = (Map0To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map0To3Node_5Bits_Spec0To8 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + Map0To3Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 3; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + V getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To3Node_5Bits_Spec0To8 that = (Map0To3Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Map0To4Node_5Bits_Spec0To8 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + Map0To4Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + V getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To4Node_5Bits_Spec0To8 that = (Map0To4Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Map0To5Node_5Bits_Spec0To8 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + Map0To5Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + V getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To5Node_5Bits_Spec0To8 that = (Map0To5Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Map0To6Node_5Bits_Spec0To8 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + Map0To6Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + V getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 6; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To6Node_5Bits_Spec0To8 that = (Map0To6Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + + return true; + } + + } + + private static final class Map0To7Node_5Bits_Spec0To8 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + Map0To7Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + case 6: + return node7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + V getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 7; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, node7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, node7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, node7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, node7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, node7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + result = prime * result + node7.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To7Node_5Bits_Spec0To8 that = (Map0To7Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + if (!(node7.equals(that.node7))) { + return false; + } + + return true; + } + + } + + private static final class Map0To8Node_5Bits_Spec0To8 + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + Map0To8Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7, final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + case 6: + return node7; + case 7: + return node8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + V getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 8; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, node7, + node8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, node7, + node8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, node7, + node8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, node7, + node8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, node7, + node8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, node7, + node8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node, + node8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + result = prime * result + node7.hashCode(); + result = prime * result + node8.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To8Node_5Bits_Spec0To8 that = (Map0To8Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + if (!(node7.equals(that.node7))) { + return false; + } + if (!(node8.equals(that.node8))) { + return false; + } + + return true; + } + + } + + private static final class Map1To0Node_5Bits_Spec0To8 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + + Map1To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 2; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To0Node_5Bits_Spec0To8 that = (Map1To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + + return true; + } + + } + + private static final class Map1To1Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + + Map1To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 3; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To1Node_5Bits_Spec0To8 that = (Map1To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map1To2Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map1To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To2Node_5Bits_Spec0To8 that = (Map1To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map1To3Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + Map1To3Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To3Node_5Bits_Spec0To8 that = (Map1To3Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Map1To4Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + Map1To4Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To4Node_5Bits_Spec0To8 that = (Map1To4Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Map1To5Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + Map1To5Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To5Node_5Bits_Spec0To8 that = (Map1To5Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Map1To6Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + Map1To6Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 6; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To6Node_5Bits_Spec0To8 that = (Map1To6Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + + return true; + } + + } + + private static final class Map1To7Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + Map1To7Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 9; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + case 6: + return node7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 7; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, node4, + node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node, node7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7); + case 7: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + result = prime * result + node7.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To7Node_5Bits_Spec0To8 that = (Map1To7Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + if (!(node7.equals(that.node7))) { + return false; + } + + return true; + } + + } + + private static final class Map2To0Node_5Bits_Spec0To8 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + + Map2To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To0Node_5Bits_Spec0To8 that = (Map2To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + + return true; + } + + } + + private static final class Map2To1Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + + Map2To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To1Node_5Bits_Spec0To8 that = (Map2To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map2To2Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map2To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To2Node_5Bits_Spec0To8 that = (Map2To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map2To3Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + Map2To3Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To3Node_5Bits_Spec0To8 that = (Map2To3Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Map2To4Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + Map2To4Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To4Node_5Bits_Spec0To8 that = (Map2To4Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Map2To5Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + Map2To5Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 9; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, node2, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, node2, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To5Node_5Bits_Spec0To8 that = (Map2To5Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Map2To6Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + Map2To6Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 10; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 6; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, node2, + node3, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, node2, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, node4, + node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, node4, + node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, node4, + node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node, + node5, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, node4, + node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, node4, + node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node4, + node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node5, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To6Node_5Bits_Spec0To8 that = (Map2To6Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + + return true; + } + + } + + private static final class Map3To0Node_5Bits_Spec0To8 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + + Map3To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map3To0Node_5Bits_Spec0To8 that = (Map3To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + + return true; + } + + } + + private static final class Map3To1Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + + Map3To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map3To1Node_5Bits_Spec0To8 that = (Map3To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map3To2Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map3To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map3To2Node_5Bits_Spec0To8 that = (Map3To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map3To3Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + Map3To3Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 9; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map3To3Node_5Bits_Spec0To8 that = (Map3To3Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Map3To4Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + Map3To4Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 10; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node, + node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node, + node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map3To4Node_5Bits_Spec0To8 that = (Map3To4Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Map3To5Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + Map3To5Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 11; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, node2, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, node2, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node3, node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, node2, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node, + node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node, node4, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node, node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, node2, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node, + node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node, node4, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node, node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node2, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node4, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node2, node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map3To5Node_5Bits_Spec0To8 that = (Map3To5Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Map4To0Node_5Bits_Spec0To8 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + + Map4To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map4To0Node_5Bits_Spec0To8 that = (Map4To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + + return true; + } + + } + + private static final class Map4To1Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + + Map4To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 9; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map4To1Node_5Bits_Spec0To8 that = (Map4To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map4To2Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map4To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 10; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map4To2Node_5Bits_Spec0To8 that = (Map4To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map4To3Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + Map4To3Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 11; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, node2, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map4To3Node_5Bits_Spec0To8 that = (Map4To3Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Map4To4Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + Map4To4Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 12; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, node2, + node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node2, node3, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node3, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map4To4Node_5Bits_Spec0To8 that = (Map4To4Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Map5To0Node_5Bits_Spec0To8 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + + Map5To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 10; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + val5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map5To0Node_5Bits_Spec0To8 that = (Map5To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(val5.equals(that.val5))) { + return false; + } + + return true; + } + + } + + private static final class Map5To1Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + + Map5To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 11; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + val5.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map5To1Node_5Bits_Spec0To8 that = (Map5To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(val5.equals(that.val5))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map5To2Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map5To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 12; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + val5.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map5To2Node_5Bits_Spec0To8 that = (Map5To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(val5.equals(that.val5))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map5To3Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + Map5To3Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, + final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 13; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, node1, node2, node3); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + node1, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + val5.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map5To3Node_5Bits_Spec0To8 that = (Map5To3Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(val5.equals(that.val5))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Map6To0Node_5Bits_Spec0To8 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + + Map6To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 12; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 6; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, key6, val6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, key6, val6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, key6, val6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + key6, val6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + key6, val6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + key6, val6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + key6, val6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key6, val6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + val5.hashCode(); + result = prime * result + key6.hashCode(); + result = prime * result + val6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map6To0Node_5Bits_Spec0To8 that = (Map6To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(val5.equals(that.val5))) { + return false; + } + if (!(key6.equals(that.key6))) { + return false; + } + if (!(val6.equals(that.val6))) { + return false; + } + + return true; + } + + } + + private static final class Map6To1Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final CompactMapNode node1; + + Map6To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 13; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 6; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, key6, val6, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, key6, val6, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, key6, val6, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + key6, val6, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + key6, val6, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + key6, val6, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + key6, val6, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key6, val6, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + val5.hashCode(); + result = prime * result + key6.hashCode(); + result = prime * result + val6.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map6To1Node_5Bits_Spec0To8 that = (Map6To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(val5.equals(that.val5))) { + return false; + } + if (!(key6.equals(that.key6))) { + return false; + } + if (!(val6.equals(that.val6))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map6To2Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map6To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 14; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 6; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, key6, val6, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, key6, val6, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, key6, val6, node1, node2); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + key6, val6, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + key6, val6, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + key6, val6, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + key6, val6, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key6, val6, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + val5.hashCode(); + result = prime * result + key6.hashCode(); + result = prime * result + val6.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map6To2Node_5Bits_Spec0To8 that = (Map6To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(val5.equals(that.val5))) { + return false; + } + if (!(key6.equals(that.key6))) { + return false; + } + if (!(val6.equals(that.val6))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map7To0Node_5Bits_Spec0To8 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + + Map7To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 14; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 7; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, key6, val6, key7, val7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val, key7, val7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, key6, val6, key7, val7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, key6, val6, key7, val7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key, val, key7, val7); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + key6, val6, key7, val7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + key6, val6, key7, val7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + key6, val6, key7, val7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + key6, val6, key7, val7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key6, val6, key7, val7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key7, val7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + val5.hashCode(); + result = prime * result + key6.hashCode(); + result = prime * result + val6.hashCode(); + result = prime * result + key7.hashCode(); + result = prime * result + val7.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map7To0Node_5Bits_Spec0To8 that = (Map7To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(val5.equals(that.val5))) { + return false; + } + if (!(key6.equals(that.key6))) { + return false; + } + if (!(val6.equals(that.val6))) { + return false; + } + if (!(key7.equals(that.key7))) { + return false; + } + if (!(val7.equals(that.val7))) { + return false; + } + + return true; + } + + } + + private static final class Map7To1Node_5Bits_Spec0To8 extends CompactMixedMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final CompactMapNode node1; + + Map7To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 15; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 7; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, key6, val6, key7, val7, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val, key7, val7, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, key6, val6, key7, val7, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, key6, val6, key7, val7, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key, val, key7, val7, node1); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + key6, val6, key7, val7, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + key6, val6, key7, val7, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + key6, val6, key7, val7, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + key6, val6, key7, val7, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key6, val6, key7, val7, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key7, val7, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + final V val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + val5.hashCode(); + result = prime * result + key6.hashCode(); + result = prime * result + val6.hashCode(); + result = prime * result + key7.hashCode(); + result = prime * result + val7.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map7To1Node_5Bits_Spec0To8 that = (Map7To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(val5.equals(that.val5))) { + return false; + } + if (!(key6.equals(that.key6))) { + return false; + } + if (!(val6.equals(that.val6))) { + return false; + } + if (!(key7.equals(that.key7))) { + return false; + } + if (!(val7.equals(that.val7))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map8To0Node_5Bits_Spec0To8 + extends CompactValuesOnlyMapNode { + + private final K key1; + private final V val1; + private final K key2; + private final V val2; + private final K key3; + private final V val3; + private final K key4; + private final V val4; + private final K key5; + private final V val5; + private final K key6; + private final V val6; + private final K key7; + private final V val7; + private final K key8; + private final V val8; + + Map8To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final V val1, final K key2, final V val2, final K key3, + final V val3, final K key4, final V val4, final K key5, final V val5, final K key6, + final V val6, final K key7, final V val7, final K key8, final V val8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 16; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + V getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 8; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final V val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val, key7, val7, key8, val8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val, key8, val8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key, final V val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, key6, val6, key7, val7, key8, val8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key, val, key7, val7, key8, val8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key, val, key8, val8); + case 8: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key7, val7, key8, val8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key8, val8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + val1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + val2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + val3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + val4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + val5.hashCode(); + result = prime * result + key6.hashCode(); + result = prime * result + val6.hashCode(); + result = prime * result + key7.hashCode(); + result = prime * result + val7.hashCode(); + result = prime * result + key8.hashCode(); + result = prime * result + val8.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map8To0Node_5Bits_Spec0To8 that = (Map8To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(val1.equals(that.val1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(val2.equals(that.val2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(val3.equals(that.val3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(val4.equals(that.val4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(val5.equals(that.val5))) { + return false; + } + if (!(key6.equals(that.key6))) { + return false; + } + if (!(val6.equals(that.val6))) { + return false; + } + if (!(key7.equals(that.key7))) { + return false; + } + if (!(val7.equals(that.val7))) { + return false; + } + if (!(key8.equals(that.key8))) { + return false; + } + if (!(val8.equals(that.val8))) { + return false; + } + + return true; + } + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieMap_5Bits_Spec0To8_IntKey_IntValue.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieMap_5Bits_Spec0To8_IntKey_IntValue.java new file mode 100644 index 0000000..b4f83f5 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieMap_5Bits_Spec0To8_IntKey_IntValue.java @@ -0,0 +1,21259 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.specialized; + +import java.text.DecimalFormat; +import java.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.atomic.AtomicReference; + +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +@SuppressWarnings("rawtypes") +public class TrieMap_5Bits_Spec0To8_IntKey_IntValue + implements io.usethesource.capsule.Map.Immutable { + + @SuppressWarnings("unchecked") + private static final TrieMap_5Bits_Spec0To8_IntKey_IntValue EMPTY_MAP = + new TrieMap_5Bits_Spec0To8_IntKey_IntValue(CompactMapNode.EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractMapNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieMap_5Bits_Spec0To8_IntKey_IntValue(AbstractMapNode rootNode, int hashCode, int cachedSize) { + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + @SuppressWarnings("unchecked") + public static final io.usethesource.capsule.Map.Immutable of() { + return TrieMap_5Bits_Spec0To8_IntKey_IntValue.EMPTY_MAP; + } + + @SuppressWarnings("unchecked") + public static final io.usethesource.capsule.Map.Immutable of( + Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + io.usethesource.capsule.Map.Immutable result = + TrieMap_5Bits_Spec0To8_IntKey_IntValue.EMPTY_MAP; + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final int key = (int) keyValuePairs[i]; + final int val = (int) keyValuePairs[i + 1]; + + result = result.__put(key, val); + } + + return result; + } + + @SuppressWarnings("unchecked") + public static final io.usethesource.capsule.Map.Transient transientOf() { + return TrieMap_5Bits_Spec0To8_IntKey_IntValue.EMPTY_MAP.asTransient(); + } + + @SuppressWarnings("unchecked") + public static final io.usethesource.capsule.Map.Transient transientOf( + Object... keyValuePairs) { + if (keyValuePairs.length % 2 != 0) { + throw new IllegalArgumentException("Length of argument list is uneven: no key/value pairs."); + } + + final io.usethesource.capsule.Map.Transient result = + TrieMap_5Bits_Spec0To8_IntKey_IntValue.EMPTY_MAP.asTransient(); + + for (int i = 0; i < keyValuePairs.length; i += 2) { + final int key = (int) keyValuePairs[i]; + final int val = (int) keyValuePairs[i + 1]; + + result.__put(key, val); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it + .hasNext();) { + final Map.Entry entry = it.next(); + final int key = entry.getKey(); + final int val = entry.getValue(); + + hash += (int) key ^ (int) val; + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + public boolean containsKey(final Object o) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + return rootNode.containsKey(key, transformHashCode(key), 0); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + return rootNode.containsKey(key, transformHashCode(key), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + public java.lang.Integer get(final Object o) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public java.lang.Integer getEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public io.usethesource.capsule.Map.Immutable __put(final java.lang.Integer key, + final java.lang.Integer val) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = (int) details.getReplacedValue(); + final int valHashNew = (int) val; + + return new TrieMap_5Bits_Spec0To8_IntKey_IntValue(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = (int) val; + return new TrieMap_5Bits_Spec0To8_IntKey_IntValue(newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + public io.usethesource.capsule.Map.Immutable __putEquivalent( + final java.lang.Integer key, final java.lang.Integer val, final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(null, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int valHashOld = (int) details.getReplacedValue(); + final int valHashNew = (int) val; + + return new TrieMap_5Bits_Spec0To8_IntKey_IntValue(newRootNode, + hashCode + ((keyHash ^ valHashNew)) - ((keyHash ^ valHashOld)), cachedSize); + } + + final int valHash = (int) val; + return new TrieMap_5Bits_Spec0To8_IntKey_IntValue(newRootNode, + hashCode + ((keyHash ^ valHash)), cachedSize + 1); + } + + return this; + } + + public io.usethesource.capsule.Map.Immutable __putAll( + final Map map) { + final io.usethesource.capsule.Map.Transient tmpTransient = this.asTransient(); + tmpTransient.__putAll(map); + return tmpTransient.freeze(); + } + + public io.usethesource.capsule.Map.Immutable __putAllEquivalent( + final Map map, + final Comparator cmp) { + final io.usethesource.capsule.Map.Transient tmpTransient = this.asTransient(); + tmpTransient.__putAllEquivalent(map, cmp); + return tmpTransient.freeze(); + } + + public io.usethesource.capsule.Map.Immutable __remove(final java.lang.Integer key) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = (int) details.getReplacedValue(); + return new TrieMap_5Bits_Spec0To8_IntKey_IntValue(newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + public io.usethesource.capsule.Map.Immutable __removeEquivalent( + final java.lang.Integer key, final Comparator cmp) { + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = (int) details.getReplacedValue(); + return new TrieMap_5Bits_Spec0To8_IntKey_IntValue(newRootNode, + hashCode - ((keyHash ^ valHash)), cachedSize - 1); + } + + return this; + } + + public java.lang.Integer put(final java.lang.Integer key, final java.lang.Integer val) { + throw new UnsupportedOperationException(); + } + + public void putAll(final Map m) { + throw new UnsupportedOperationException(); + } + + public void clear() { + throw new UnsupportedOperationException(); + } + + public java.lang.Integer remove(final Object key) { + throw new UnsupportedOperationException(); + } + + public int size() { + return cachedSize; + } + + public boolean isEmpty() { + return cachedSize == 0; + } + + public Iterator keyIterator() { + return new MapKeyIterator(rootNode); + } + + public Iterator valueIterator() { + return new MapValueIterator(rootNode); + } + + public Iterator> entryIterator() { + return new MapEntryIterator(rootNode); + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.keyIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.valueIterator(); + } + + @Override + public int size() { + return TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = + entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.size(); + } + + @Override + public boolean isEmpty() { + return TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.isEmpty(); + } + + @Override + public void clear() { + TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TrieMap_5Bits_Spec0To8_IntKey_IntValue.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieMap_5Bits_Spec0To8_IntKey_IntValue) { + TrieMap_5Bits_Spec0To8_IntKey_IntValue that = (TrieMap_5Bits_Spec0To8_IntKey_IntValue) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) + return false; + + for (@SuppressWarnings("unchecked") + Iterator it = that.entrySet().iterator(); it.hasNext();) { + Map.Entry entry = it.next(); + + try { + @SuppressWarnings("unchecked") + final int key = (java.lang.Integer) entry.getKey(); + final Optional result = + rootNode.findByKey(key, transformHashCode(key), 0); + + if (!result.isPresent()) { + return false; + } else { + @SuppressWarnings("unchecked") + final int val = (java.lang.Integer) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public io.usethesource.capsule.Map.Transient asTransient() { + return new TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractMapNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator nodeIterator() { + return new TrieMap_5Bits_Spec0To8_IntKey_IntValueNodeIterator(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. Payload X Node + */ + protected int[][] arityCombinationsHistogram() { + final Iterator it = nodeIterator(); + final int[][] sumArityCombinations = new int[33][33]; + + while (it.hasNext()) { + final AbstractMapNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[33]; + + final int maxArity = 32; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[33]; + for (int cumsum = 0, i = 0; i < 33; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 33; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + abstract static class Optional { + private static final Optional EMPTY = new Optional() { + @Override + boolean isPresent() { + return false; + } + + @Override + Object get() { + return null; + } + }; + + @SuppressWarnings("unchecked") + static Optional empty() { + return EMPTY; + } + + static Optional of(T value) { + return new Value(value); + } + + abstract boolean isPresent(); + + abstract T get(); + + private static final class Value extends Optional { + private final T value; + + private Value(T value) { + this.value = value; + } + + @Override + boolean isPresent() { + return true; + } + + @Override + T get() { + return value; + } + } + } + + static final class MapResult { + private int replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(int replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static MapResult unchanged() { + return new MapResult(); + } + + private MapResult() {} + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public int getReplacedValue() { + return replacedValue; + } + } + + protected static interface INode { + } + + protected static abstract class AbstractMapNode + implements INode { + + static final int TUPLE_LENGTH = 2; + + abstract boolean containsKey(final int key, final int keyHash, final int shift); + + abstract boolean containsKey(final int key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final int key, final int keyHash, + final int shift); + + abstract Optional findByKey(final int key, final int keyHash, + final int shift, final Comparator cmp); + + abstract CompactMapNode updated(final AtomicReference mutator, final int key, + final int val, final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode updated(final AtomicReference mutator, final int key, + final int val, final int keyHash, final int shift, final MapResult details, + final Comparator cmp); + + abstract CompactMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details); + + abstract CompactMapNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final MapResult details, final Comparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractMapNode getNode(final int index); + + @Deprecated + Iterator nodeIterator() { + return new Iterator() { + + int nextIndex = 0; + final int nodeArity = AbstractMapNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) + throw new NoSuchElementException(); + return AbstractMapNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract int getKey(final int index); + + abstract int getValue(final int index); + + abstract Map.Entry getKeyValueEntry(final int index); + + @Deprecated + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + int size() { + final Iterator it = new MapKeyIterator(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactMapNode extends AbstractMapNode { + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return (int) (1 << mask); + } + + abstract int nodeMap(); + + abstract int dataMap(); + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactMapNode getNode(final int index); + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val); + + abstract CompactMapNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final int key, final int val); + + abstract CompactMapNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos); + + abstract CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node); + + abstract CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node); + + CompactMapNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + static final CompactMapNode mergeTwoKeyValPairs(final int key0, final int val0, + final int keyHash0, final int key1, final int val1, final int keyHash1, final int shift) { + assert !(key0 == key1); + + if (shift >= HASH_CODE_LENGTH) { + // throw new + // IllegalStateException("Hash collision not yet fixed."); + return new HashCollisionMapNode_5Bits_Spec0To8_IntKey_IntValue(keyHash0, + (int[]) new int[] {key0, key1}, (int[]) new int[] {val0, val1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int dataMap = (int) (bitpos(mask0) | bitpos(mask1)); + + if (mask0 < mask1) { + return nodeOf(null, (int) 0, dataMap, key0, val0, key1, val1); + } else { + return nodeOf(null, (int) 0, dataMap, key1, val1, key0, val0); + } + } else { + final CompactMapNode node = mergeTwoKeyValPairs(key0, val0, keyHash0, key1, val1, keyHash1, + shift + BIT_PARTITION_SIZE); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf(null, nodeMap, (int) 0, node); + } + } + + static final CompactMapNode EMPTY_NODE; + + static { + + EMPTY_NODE = new Map0To0Node_5Bits_Spec0To8_IntKey_IntValue(null, (int) 0, (int) 0); + + }; + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + return new BitmapIndexedMapNode(mutator, nodeMap, dataMap, nodes); + } + + @SuppressWarnings("unchecked") + static final CompactMapNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + return EMPTY_NODE; + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1) { + return new Map0To1Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2) { + return new Map0To2Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, node1, + node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map0To3Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, node1, node2, + node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map0To4Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, node1, node2, + node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + return new Map0To5Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, node1, node2, + node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + return new Map0To6Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, node1, node2, + node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7) { + return new Map0To7Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, node1, node2, + node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8) { + return new Map0To8Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, node1, node2, + node3, node4, node5, node6, node7, node8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6, final CompactMapNode node7, final CompactMapNode node8, + final CompactMapNode node9) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1) { + return new Map1To0Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1) { + return new Map1To1Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map1To2Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map1To3Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + return new Map1To4Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + return new Map1To5Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + return new Map1To6Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + return new Map1To7Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + node1, node2, node3, node4, node5, node6, node7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2) { + return new Map2To0Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1) { + return new Map2To1Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2) { + return new Map2To2Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + return new Map2To3Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + return new Map2To4Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + return new Map2To5Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6) { + return new Map2To6Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, node1, node2, node3, node4, node5, node6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[] {key1, val1, key2, val2, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3) { + return new Map3To0Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1) { + return new Map3To1Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2) { + return new Map3To2Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map3To3Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + return new Map3To4Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + return new Map3To5Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, node1, node2, node3, node4, node5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[] {key1, val1, key2, val2, key3, val3, + node6, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4) { + return new Map4To0Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1) { + return new Map4To1Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map4To2Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + return new Map4To3Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + return new Map4To4Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, node1, node2, node3, node4); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[] {key1, val1, key2, val2, key3, val3, + key4, val4, node5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5) { + return new Map5To0Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1) { + return new Map5To1Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2) { + return new Map5To2Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + return new Map5To3Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, node1, node2, node3); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[] {key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node4, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6) { + return new Map6To0Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1) { + return new Map6To1Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2) { + return new Map6To2Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, node1, node2); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[] {key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node3, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7) { + return new Map7To0Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1) { + return new Map7To1Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, node1); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final CompactMapNode node1, final CompactMapNode node2) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[] {key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node2, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8) { + return new Map8To0Node_5Bits_Spec0To8_IntKey_IntValue(mutator, nodeMap, dataMap, key1, val1, + key2, val2, key3, val3, key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final CompactMapNode node1) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, new Object[] {key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, node1}); + } + + static final CompactMapNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int val1, final int key2, final int val2, + final int key3, final int val3, final int key4, final int val4, final int key5, + final int val5, final int key6, final int val6, final int key7, final int val7, + final int key8, final int val8, final int key9, final int val9) { + return nodeOf(mutator, nodeMap, dataMap, new Object[] {key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8, key9, val9}); + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + CompactMapNode nodeAt(final int bitpos) { + return getNode(nodeIndex(bitpos)); + } + + boolean containsKey(final int key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index) == key; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return false; + } + + boolean containsKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index) == key; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).containsKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return false; + } + + Optional findByKey(final int key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index) == key) { + final java.lang.Integer result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return Optional.empty(); + } + + Optional findByKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index) == key) { + final java.lang.Integer result = getValue(index); + + return Optional.of(result); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractMapNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return Optional.empty(); + } + + CompactMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + final int currentVal = getValue(dataIndex); + + if (currentVal == val) { + return this; + } else { + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } + } else { + final int currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey), key, val, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + CompactMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + final int currentVal = getValue(dataIndex); + + if (currentVal == val) { + return this; + } else { + // update mapping + details.updated(currentVal); + return copyAndSetValue(mutator, bitpos, val); + } + } else { + final int currentVal = getValue(dataIndex); + final CompactMapNode subNodeNew = mergeTwoKeyValPairs(currentKey, currentVal, + transformHashCode(currentKey), key, val, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.updated(mutator, key, val, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key, val); + } + } + + CompactMapNode removed(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final MapResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex) == key) { + final int currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(1), getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(0), getValue(0)); + } + } else if (this.arity() == 9) { + return removeInplaceValueAndConvertToSpecializedNode(mutator, bitpos); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + details.modified(); + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + CompactMapNode removed(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final MapResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex) == key) { + final int currentVal = getValue(dataIndex); + details.updated(currentVal); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(1), getValue(1)); + } else { + return CompactMapNode.nodeOf(mutator, (int) 0, newDataMap, getKey(0), getValue(0)); + } + } else if (this.arity() == 9) { + return removeInplaceValueAndConvertToSpecializedNode(mutator, bitpos); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactMapNode subNode = nodeAt(bitpos); + final CompactMapNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + details.modified(); + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = (int) (map >> 1); + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d<#%d,#%d>", pos, Objects.hashCode(getKey(i)), + Objects.hashCode(getValue(i)))); + + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedMapNode extends CompactMapNode { + + private final int nodeMap; + private final int dataMap; + + CompactMixedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + protected static abstract class CompactNodesOnlyMapNode extends CompactMapNode { + + private final int nodeMap; + + CompactNodesOnlyMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return 0; + } + + } + + protected static abstract class CompactValuesOnlyMapNode extends CompactMapNode { + + private final int dataMap; + + CompactValuesOnlyMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return 0; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + protected static abstract class CompactEmptyMapNode extends CompactMapNode { + + CompactEmptyMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) {} + + @Override + public int nodeMap() { + return 0; + } + + @Override + public int dataMap() { + return 0; + } + + } + + private static final class BitmapIndexedMapNode extends CompactMixedMapNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedMapNode(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + super(mutator, nodeMap, dataMap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + + assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < TUPLE_LENGTH * payloadArity(); i++) { + assert ((nodes[i] instanceof CompactMapNode) == false); + } + for (int i = TUPLE_LENGTH * payloadArity(); i < nodes.length; i++) { + assert ((nodes[i] instanceof CompactMapNode) == true); + } + } + + assert arity() > 8; + assert nodeInvariant(); + } + + @Override + int getKey(final int index) { + return (int) nodes[TUPLE_LENGTH * index]; + } + + @Override + int getValue(final int index) { + return (int) nodes[TUPLE_LENGTH * index + 1]; + } + + Map.Entry getKeyValueEntry(final int index) { + return entryOf((int) nodes[TUPLE_LENGTH * index], (int) nodes[TUPLE_LENGTH * index + 1]); + } + + @SuppressWarnings("unchecked") + @Override + CompactMapNode getNode(final int index) { + return (CompactMapNode) nodes[nodes.length - 1 - index]; + } + + @Override + boolean hasPayload() { + return dataMap() != 0; + } + + @Override + int payloadArity() { + return java.lang.Integer.bitCount(dataMap()); + } + + @Override + boolean hasNodes() { + return nodeMap() != 0; + } + + @Override + int nodeArity() { + return java.lang.Integer.bitCount(nodeMap()); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + ((int) dataMap()); + result = prime * result + ((int) dataMap()); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedMapNode that = (BitmapIndexedMapNode) other; + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + if (!Arrays.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos) + 1; + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = val; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(bitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length + 2]; + + // copy 'src' and insert 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + dst[idx + 1] = val; + System.arraycopy(src, idx, dst, idx + 2, src.length - idx); + + return nodeOf(mutator, nodeMap(), (int) (dataMap() | bitpos), dst); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length - 2]; + + // copy 'src' and remove 2 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 2, dst, idx, src.length - idx - 2); + + return nodeOf(mutator, nodeMap(), (int) (dataMap() ^ bitpos), dst); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 2 + 1]; + + // copy 'src' and remove 2 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 2, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 2, dst, idxNew + 1, src.length - idxNew - 2); + + return nodeOf(mutator, (int) (nodeMap() | bitpos), (int) (dataMap() ^ bitpos), dst); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 2]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 2 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = node.getKey(0); + dst[idxNew + 1] = node.getValue(0); + System.arraycopy(src, idxNew, dst, idxNew + 2, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 2, src.length - idxOld - 1); + + return nodeOf(mutator, (int) (nodeMap() ^ bitpos), (int) (dataMap() | bitpos), dst); + } + + @Override + CompactMapNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (payloadArity()) { // 0 <= payloadArity <= 9 // or ts.nMax + case 1: { + + switch (valIndex) { + case 0: { + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + final CompactMapNode node8 = getNode(7); + + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node7, + node8); + + } + case 2: { + int key1; + int val1; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + final CompactMapNode node7 = getNode(6); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node7); + + } + case 3: { + int key1; + int val1; + int key2; + int val2; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + final CompactMapNode node6 = getNode(5); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node6); + + } + case 4: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + final CompactMapNode node5 = getNode(4); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node3, node4, node5); + + } + case 5: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + final CompactMapNode node4 = getNode(3); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4); + + } + case 6: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + final CompactMapNode node3 = getNode(2); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3); + + } + case 7: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + final CompactMapNode node2 = getNode(1); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2); + + } + case 8: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + int key7; + int val7; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactMapNode node1 = getNode(0); + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + + } + case 9: { + int key1; + int val1; + int key2; + int val2; + int key3; + int val3; + int key4; + int val4; + int key5; + int val5; + int key6; + int val6; + int key7; + int val7; + int key8; + int val8; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + val1 = getValue(1); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 1: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(2); + val2 = getValue(2); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 2: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(3); + val3 = getValue(3); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 3: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(4); + val4 = getValue(4); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 4: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(5); + val5 = getValue(5); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 5: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(6); + val6 = getValue(6); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 6: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(7); + val7 = getValue(7); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 7: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(8); + val8 = getValue(8); + break; + } + case 8: { + + key1 = getKey(0); + val1 = getValue(0); + key2 = getKey(1); + val2 = getValue(1); + key3 = getKey(2); + val3 = getValue(2); + key4 = getKey(3); + val4 = getValue(3); + key5 = getKey(4); + val5 = getValue(4); + key6 = getKey(5); + val6 = getValue(5); + key7 = getKey(6); + val7 = getValue(6); + key8 = getKey(7); + val8 = getValue(7); + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + + } + default: + throw new IllegalStateException("Index out of range."); + } + } + } + + private static final class HashCollisionMapNode_5Bits_Spec0To8_IntKey_IntValue + extends CompactMapNode { + private final int[] keys; + private final int[] vals; + private final int hash; + + HashCollisionMapNode_5Bits_Spec0To8_IntKey_IntValue(final int hash, final int[] keys, + final int[] vals) { + this.keys = keys; + this.vals = vals; + this.hash = hash; + + assert payloadArity() >= 2; + } + + boolean containsKey(final int key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (int k : keys) { + if (k == key) { + return true; + } + } + } + return false; + } + + boolean containsKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (int k : keys) { + if (k == key) { + return true; + } + } + } + return false; + } + + Optional findByKey(final int key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final int _key = keys[i]; + if (key == _key) { + final int val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + Optional findByKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final int _key = keys[i]; + if (key == _key) { + final int val = vals[i]; + return Optional.of(val); + } + } + return Optional.empty(); + } + + CompactMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx] == key) { + final int currentVal = vals[idx]; + + if (currentVal == val) { + return this; + } else { + // add new mapping + final int[] src = this.vals; + final int[] dst = new int[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode_5Bits_Spec0To8_IntKey_IntValue(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + final int[] keysNew = new int[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final int[] valsNew = new int[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits_Spec0To8_IntKey_IntValue(keyHash, keysNew, valsNew); + } + + CompactMapNode updated(final AtomicReference mutator, final int key, final int val, + final int keyHash, final int shift, final MapResult details, final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx] == key) { + final int currentVal = vals[idx]; + + if (currentVal == val) { + return this; + } else { + // add new mapping + final int[] src = this.vals; + final int[] dst = new int[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = val; + + final CompactMapNode thisNew = + new HashCollisionMapNode_5Bits_Spec0To8_IntKey_IntValue(this.hash, this.keys, dst); + + details.updated(currentVal); + return thisNew; + } + } + } + + final int[] keysNew = new int[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + final int[] valsNew = new int[this.vals.length + 1]; + + // copy 'this.vals' and insert 1 element(s) at position + // 'vals.length' + System.arraycopy(this.vals, 0, valsNew, 0, vals.length); + valsNew[vals.length + 0] = val; + System.arraycopy(this.vals, vals.length, valsNew, vals.length + 1, + this.vals.length - vals.length); + + details.modified(); + return new HashCollisionMapNode_5Bits_Spec0To8_IntKey_IntValue(keyHash, keysNew, valsNew); + } + + CompactMapNode removed(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final MapResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx] == key) { + final int currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final int theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final int theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details); + } else { + final int[] keysNew = new int[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final int[] valsNew = new int[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits_Spec0To8_IntKey_IntValue(keyHash, keysNew, + valsNew); + } + } + } + return this; + } + + CompactMapNode removed(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final MapResult details, final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx] == key) { + final int currentVal = vals[idx]; + details.updated(currentVal); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final int theOtherKey = (idx == 0) ? keys[1] : keys[0]; + final int theOtherVal = (idx == 0) ? vals[1] : vals[0]; + return CompactMapNode.nodeOf(mutator).updated(mutator, theOtherKey, theOtherVal, + keyHash, 0, details, cmp); + } else { + final int[] keysNew = new int[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + final int[] valsNew = new int[this.vals.length - 1]; + + // copy 'this.vals' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.vals, 0, valsNew, 0, idx); + System.arraycopy(this.vals, idx + 1, valsNew, idx, this.vals.length - idx - 1); + + return new HashCollisionMapNode_5Bits_Spec0To8_IntKey_IntValue(keyHash, keysNew, + valsNew); + } + } + } + return this; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return keys.length; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + int arity() { + return payloadArity(); + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + int getKey(final int index) { + return keys[index]; + } + + @Override + int getValue(final int index) { + return vals[index]; + } + + Map.Entry getKeyValueEntry(final int index) { + return entryOf(keys[index], vals[index]); + } + + @Override + public CompactMapNode getNode(int index) { + throw new IllegalStateException("Is leaf node."); + } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + hash; + result = prime * result + Arrays.hashCode(keys); + result = prime * result + Arrays.hashCode(vals); + return result; + } + + @Override + public boolean equals(Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + HashCollisionMapNode_5Bits_Spec0To8_IntKey_IntValue that = + (HashCollisionMapNode_5Bits_Spec0To8_IntKey_IntValue) other; + + if (hash != that.hash) { + return false; + } + + if (arity() != that.arity()) { + return false; + } + + /* + * Linear scan for each key, because of arbitrary element order. + */ + outerLoop: for (int i = 0; i < that.payloadArity(); i++) { + final int otherKey = that.getKey(i); + final int otherVal = that.getValue(i); + + for (int j = 0; j < keys.length; j++) { + final int key = keys[j]; + final int val = vals[j]; + + if (key == otherKey && val == otherVal) { + continue outerLoop; + } + } + return false; + } + + return true; + } + + @Override + CompactMapNode copyAndSetValue(final AtomicReference mutator, final int bitpos, + final int val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key, final int val) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactMapNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + int nodeMap() { + throw new UnsupportedOperationException(); + } + + @Override + int dataMap() { + throw new UnsupportedOperationException(); + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractMapIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractMapNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + @SuppressWarnings("unchecked") + AbstractMapNode[] nodes = new AbstractMapNode[MAX_DEPTH]; + + AbstractMapIterator(AbstractMapNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractMapNode nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class MapKeyIterator extends AbstractMapIterator + implements Iterator { + + MapKeyIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public java.lang.Integer next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + protected static class MapValueIterator extends AbstractMapIterator + implements Iterator { + + MapValueIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public java.lang.Integer next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getValue(currentValueCursor++); + } + } + + } + + protected static class MapEntryIterator extends AbstractMapIterator + implements Iterator> { + + MapEntryIterator(AbstractMapNode rootNode) { + super(rootNode); + } + + @Override + public Map.Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKeyValueEntry(currentValueCursor++); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieMap_5Bits_Spec0To8_IntKey_IntValueNodeIterator + implements Iterator { + + final Deque> nodeIteratorStack; + + TrieMap_5Bits_Spec0To8_IntKey_IntValueNodeIterator(AbstractMapNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractMapNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractMapNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue + implements io.usethesource.capsule.Map.Transient { + final private AtomicReference mutator; + private AbstractMapNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue( + TrieMap_5Bits_Spec0To8_IntKey_IntValue trieMap_5Bits_Spec0To8_IntKey_IntValue) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieMap_5Bits_Spec0To8_IntKey_IntValue.rootNode; + this.hashCode = trieMap_5Bits_Spec0To8_IntKey_IntValue.hashCode; + this.cachedSize = trieMap_5Bits_Spec0To8_IntKey_IntValue.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator> it = entryIterator(); it + .hasNext();) { + final Map.Entry entry = it.next(); + final int key = entry.getKey(); + final int val = entry.getValue(); + + hash += (int) key ^ (int) val; + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public java.lang.Integer put(final java.lang.Integer key, final java.lang.Integer val) { + throw new UnsupportedOperationException(); + } + + public void putAll(final Map m) { + throw new UnsupportedOperationException(); + } + + public void clear() { + throw new UnsupportedOperationException(); + } + + public java.lang.Integer remove(final Object key) { + throw new UnsupportedOperationException(); + } + + public boolean containsKey(final Object o) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + return rootNode.containsKey(key, transformHashCode(key), 0); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsKeyEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + return rootNode.containsKey(key, transformHashCode(key), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + public boolean containsValue(final Object o) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (iterator.next().equals(o)) { + return true; + } + } + return false; + } + + public boolean containsValueEquivalent(final Object o, final Comparator cmp) { + for (Iterator iterator = valueIterator(); iterator.hasNext();) { + if (cmp.compare(iterator.next(), o) == 0) { + return true; + } + } + return false; + } + + public java.lang.Integer get(final Object o) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public java.lang.Integer getEquivalent(final Object o, final Comparator cmp) { + try { + @SuppressWarnings("unchecked") + final int key = (int) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + public java.lang.Integer __put(final java.lang.Integer key, final java.lang.Integer val) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int old = details.getReplacedValue(); + + final int valHashOld = (int) old; + final int valHashNew = (int) val; + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } else { + final int valHashNew = (int) val; + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + public java.lang.Integer __putEquivalent(final java.lang.Integer key, + final java.lang.Integer val, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.updated(mutator, key, val, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + if (details.hasReplacedValue()) { + final int old = details.getReplacedValue(); + + final int valHashOld = (int) old; + final int valHashNew = (int) val; + + rootNode = newRootNode; + hashCode = hashCode + (keyHash ^ valHashNew) - (keyHash ^ valHashOld); + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } else { + final int valHashNew = (int) val; + rootNode = newRootNode; + hashCode += (keyHash ^ valHashNew); + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return null; + } + + public boolean __putAll( + final Map map) { + boolean modified = false; + + for (Map.Entry entry : map + .entrySet()) { + final boolean isPresent = this.containsKey(entry.getKey()); + final java.lang.Integer replaced = this.__put(entry.getKey(), entry.getValue()); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + public boolean __putAllEquivalent( + final Map map, + final Comparator cmp) { + boolean modified = false; + + for (Map.Entry entry : map + .entrySet()) { + final boolean isPresent = this.containsKeyEquivalent(entry.getKey(), cmp); + final java.lang.Integer replaced = + this.__putEquivalent(entry.getKey(), entry.getValue(), cmp); + + if (!isPresent || replaced != null) { + modified = true; + } + } + + return modified; + } + + public java.lang.Integer __remove(final java.lang.Integer key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = (int) details.getReplacedValue(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + public java.lang.Integer __removeEquivalent(final java.lang.Integer key, + final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final MapResult details = MapResult.unchanged(); + + final CompactMapNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + assert details.hasReplacedValue(); + final int valHash = (int) details.getReplacedValue(); + + rootNode = newRootNode; + hashCode = hashCode - (keyHash ^ valHash); + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return details.getReplacedValue(); + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return null; + } + + public int size() { + return cachedSize; + } + + public boolean isEmpty() { + return cachedSize == 0; + } + + public Iterator keyIterator() { + return new TransientMapKeyIterator(this); + } + + public Iterator valueIterator() { + return new TransientMapValueIterator(this); + } + + public Iterator> entryIterator() { + return new TransientMapEntryIterator(this); + } + + public static class TransientMapKeyIterator extends MapKeyIterator { + final TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue collection; + int lastKey; + + public TransientMapKeyIterator( + final TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue collection) { + super(collection.rootNode); + this.collection = collection; + } + + public java.lang.Integer next() { + return lastKey = super.next(); + } + + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(lastKey); + } + } + + public static class TransientMapValueIterator extends MapValueIterator { + final TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue collection; + + public TransientMapValueIterator( + final TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue collection) { + super(collection.rootNode); + this.collection = collection; + } + + public java.lang.Integer next() { + return super.next(); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + public static class TransientMapEntryIterator extends MapEntryIterator { + final TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue collection; + + public TransientMapEntryIterator( + final TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue collection) { + super(collection.rootNode); + this.collection = collection; + } + + public Map.Entry next() { + return super.next(); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + @Override + public Set keySet() { + Set keySet = null; + + if (keySet == null) { + keySet = new AbstractSet() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.keyIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.containsKey(k); + } + }; + } + + return keySet; + } + + @Override + public Collection values() { + Collection values = null; + + if (values == null) { + values = new AbstractCollection() { + @Override + public Iterator iterator() { + return TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.valueIterator(); + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.clear(); + } + + @Override + public boolean contains(Object v) { + return TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.containsValue(v); + } + }; + } + + return values; + } + + @Override + public Set> entrySet() { + Set> entrySet = null; + + if (entrySet == null) { + entrySet = new AbstractSet>() { + @Override + public Iterator> iterator() { + return new Iterator>() { + private final Iterator> i = + entryIterator(); + + @Override + public boolean hasNext() { + return i.hasNext(); + } + + @Override + public Map.Entry next() { + return i.next(); + } + + @Override + public void remove() { + i.remove(); + } + }; + } + + @Override + public int size() { + return TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.size(); + } + + @Override + public boolean isEmpty() { + return TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.isEmpty(); + } + + @Override + public void clear() { + TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.clear(); + } + + @Override + public boolean contains(Object k) { + return TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue.this.containsKey(k); + } + }; + } + + return entrySet; + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue) { + TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue that = + (TransientTrieMap_5Bits_Spec0To8_IntKey_IntValue) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Map) { + Map that = (Map) other; + + if (this.size() != that.size()) + return false; + + for (@SuppressWarnings("unchecked") + Iterator it = that.entrySet().iterator(); it.hasNext();) { + Map.Entry entry = it.next(); + + try { + @SuppressWarnings("unchecked") + final int key = (java.lang.Integer) entry.getKey(); + final Optional result = + rootNode.findByKey(key, transformHashCode(key), 0); + + if (!result.isPresent()) { + return false; + } else { + @SuppressWarnings("unchecked") + final int val = (java.lang.Integer) entry.getValue(); + + if (!result.get().equals(val)) { + return false; + } + } + } catch (ClassCastException unused) { + return false; + } + } + + return true; + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public io.usethesource.capsule.Map.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieMap_5Bits_Spec0To8_IntKey_IntValue(rootNode, hashCode, cachedSize); + } + } + + private static final class Map0To0Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactEmptyMapNode { + + Map0To0Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap) { + super(mutator, nodeMap, dataMap); + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return false; + } + + @Override + int slotArity() { + return 0; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_EMPTY; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + int result = 1; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + return true; + } + + } + + private static final class Map0To1Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + + Map0To1Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 1; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To1Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map0To1Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map0To2Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map0To2Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 2; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To2Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map0To2Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map0To3Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + Map0To3Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 3; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To3Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map0To3Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Map0To4Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + Map0To4Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To4Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map0To4Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Map0To5Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + Map0To5Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To5Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map0To5Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Map0To6Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + Map0To6Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 6; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To6Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map0To6Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + + return true; + } + + } + + private static final class Map0To7Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + Map0To7Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + case 6: + return node7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 7; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, node7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, node7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, node7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, node7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, node7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + result = prime * result + node7.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To7Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map0To7Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + if (!(node7.equals(that.node7))) { + return false; + } + + return true; + } + + } + + private static final class Map0To8Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactNodesOnlyMapNode { + + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + private final CompactMapNode node8; + + Map0To8Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5, final CompactMapNode node6, final CompactMapNode node7, + final CompactMapNode node8) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + case 6: + return node7; + case 7: + return node8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getValue(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + Map.Entry getKeyValueEntry(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 8; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, node7, + node8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, node7, + node8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, node7, + node8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, node7, + node8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, node7, + node8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, node7, + node8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node, + node8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + result = prime * result + node7.hashCode(); + result = prime * result + node8.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map0To8Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map0To8Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + if (!(node7.equals(that.node7))) { + return false; + } + if (!(node8.equals(that.node8))) { + return false; + } + + return true; + } + + } + + private static final class Map1To0Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + + Map1To0Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 2; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To0Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map1To0Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + + return true; + } + + } + + private static final class Map1To1Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + + Map1To1Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 3; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To1Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map1To1Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map1To2Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map1To2Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To2Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map1To2Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map1To3Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + Map1To3Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To3Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map1To3Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Map1To4Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + Map1To4Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To4Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map1To4Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Map1To5Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + Map1To5Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To5Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map1To5Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Map1To6Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + Map1To6Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 6; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To6Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map1To6Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + + return true; + } + + } + + private static final class Map1To7Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + private final CompactMapNode node7; + + Map1To7Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4, final CompactMapNode node5, final CompactMapNode node6, + final CompactMapNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 9; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + case 6: + return node7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 7; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, node4, + node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node3, node4, node5, + node6, node7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node4, node5, + node6, node7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node5, + node6, node7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node6, node7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node, node7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7); + case 7: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node2, node3, node4, + node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node2, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node3, node4, + node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node3, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node4, + node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node4, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + result = prime * result + node7.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map1To7Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map1To7Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + if (!(node7.equals(that.node7))) { + return false; + } + + return true; + } + + } + + private static final class Map2To0Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + + Map2To0Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To0Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map2To0Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + + return true; + } + + } + + private static final class Map2To1Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + + Map2To1Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To1Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map2To1Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map2To2Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map2To2Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To2Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map2To2Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map2To3Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + Map2To3Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To3Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map2To3Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Map2To4Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + Map2To4Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To4Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map2To4Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Map2To5Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + Map2To5Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 9; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, node2, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, node2, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To5Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map2To5Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Map2To6Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + private final CompactMapNode node6; + + Map2To6Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3, final CompactMapNode node4, final CompactMapNode node5, + final CompactMapNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 10; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 6; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, node1, node2, node3, + node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, node1, node2, node3, + node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, node2, + node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, node2, + node3, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, node2, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node2, node3, + node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node3, + node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node4, node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node, node2, node3, node4, + node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node, node3, node4, + node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node, node4, + node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, node, + node5, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node, node2, node3, node4, + node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node, node3, node4, + node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node, node4, + node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, node, + node5, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node, node6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, node1, node2, node3, node4, + node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node2, + node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node2, + node3, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node2, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node3, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, node1, + node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, node1, + node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, node1, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map2To6Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map2To6Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + + return true; + } + + } + + private static final class Map3To0Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + + Map3To0Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map3To0Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map3To0Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + + return true; + } + + } + + private static final class Map3To1Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + + Map3To1Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, + val3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, + val3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, + val3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, + val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map3To1Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map3To1Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map3To2Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map3To2Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map3To2Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map3To2Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map3To3Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + Map3To3Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 9; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map3To3Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map3To3Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Map3To4Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + Map3To4Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 10; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node, + node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node, + node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map3To4Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map3To4Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Map3To5Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + private final CompactMapNode node5; + + Map3To5Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final CompactMapNode node1, + final CompactMapNode node2, final CompactMapNode node3, final CompactMapNode node4, + final CompactMapNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 11; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, node1, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, node1, node2, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, node1, node2, + node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node3, node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node, node1, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node, node2, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node, + node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node, node4, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node, node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, node1, node2, node3, + node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node, node1, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node, node2, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node, + node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node, node4, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node, node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, node1, node2, node3, + node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node, node1, node2, + node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node, node2, + node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node, + node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node, node4, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node, node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, node1, node2, node3, + node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node2, node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + node1, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map3To5Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map3To5Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Map4To0Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + + Map4To0Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map4To0Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map4To0Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + + return true; + } + + } + + private static final class Map4To1Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + + Map4To1Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 9; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map4To1Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map4To1Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map4To2Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map4To2Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 10; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map4To2Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map4To2Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map4To3Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + Map4To3Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 11; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, node2, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map4To3Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map4To3Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Map4To4Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + private final CompactMapNode node4; + + Map4To4Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final CompactMapNode node1, final CompactMapNode node2, final CompactMapNode node3, + final CompactMapNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 12; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + node1, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, node2, + node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, node2, + node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, node2, + node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, node2, + node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node, + node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, node1, + node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node2, node3, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node3, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, node1, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map4To4Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map4To4Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Map5To0Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + + Map5To0Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 10; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + result = prime * result + (int) key5; + result = prime * result + (int) val5; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map5To0Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map5To0Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(val5 == that.val5)) { + return false; + } + + return true; + } + + } + + private static final class Map5To1Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + + Map5To1Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 11; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + result = prime * result + (int) key5; + result = prime * result + (int) val5; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map5To1Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map5To1Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(val5 == that.val5)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map5To2Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map5To2Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1, final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 12; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + result = prime * result + (int) key5; + result = prime * result + (int) val5; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map5To2Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map5To2Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(val5 == that.val5)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map5To3Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final CompactMapNode node1; + private final CompactMapNode node2; + private final CompactMapNode node3; + + Map5To3Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final CompactMapNode node1, final CompactMapNode node2, + final CompactMapNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 13; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, node1, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, node1, node2, node3); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + node1, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node2, node3); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node3); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + result = prime * result + (int) key5; + result = prime * result + (int) val5; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map5To3Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map5To3Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(val5 == that.val5)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Map6To0Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + + Map6To0Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 12; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 6; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, key6, val6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, key6, val6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, key6, val6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + key6, val6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + key6, val6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + key6, val6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + key6, val6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key6, val6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + result = prime * result + (int) key5; + result = prime * result + (int) val5; + result = prime * result + (int) key6; + result = prime * result + (int) val6; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map6To0Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map6To0Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(val5 == that.val5)) { + return false; + } + if (!(key6 == that.key6)) { + return false; + } + if (!(val6 == that.val6)) { + return false; + } + + return true; + } + + } + + private static final class Map6To1Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final CompactMapNode node1; + + Map6To1Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, + final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 13; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 6; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, key6, val6, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, key6, val6, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, key6, val6, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + key6, val6, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + key6, val6, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + key6, val6, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + key6, val6, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key6, val6, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + result = prime * result + (int) key5; + result = prime * result + (int) val5; + result = prime * result + (int) key6; + result = prime * result + (int) val6; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map6To1Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map6To1Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(val5 == that.val5)) { + return false; + } + if (!(key6 == that.key6)) { + return false; + } + if (!(val6 == that.val6)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map6To2Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final CompactMapNode node1; + private final CompactMapNode node2; + + Map6To2Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final CompactMapNode node1, + final CompactMapNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 14; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 6; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, key6, val6, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, key6, val6, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, key6, val6, node1, node2); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key, val, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + key6, val6, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + key6, val6, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + key6, val6, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + key6, val6, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key6, val6, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node2); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + result = prime * result + (int) key5; + result = prime * result + (int) val5; + result = prime * result + (int) key6; + result = prime * result + (int) val6; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map6To2Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map6To2Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(val5 == that.val5)) { + return false; + } + if (!(key6 == that.key6)) { + return false; + } + if (!(val6 == that.val6)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Map7To0Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + + Map7To0Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 14; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 7; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, key6, val6, key7, val7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val, key7, val7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, key6, val6, key7, val7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, key6, val6, key7, val7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key, val, key7, val7); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + key6, val6, key7, val7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + key6, val6, key7, val7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + key6, val6, key7, val7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + key6, val6, key7, val7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key6, val6, key7, val7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key7, val7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + result = prime * result + (int) key5; + result = prime * result + (int) val5; + result = prime * result + (int) key6; + result = prime * result + (int) val6; + result = prime * result + (int) key7; + result = prime * result + (int) val7; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map7To0Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map7To0Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(val5 == that.val5)) { + return false; + } + if (!(key6 == that.key6)) { + return false; + } + if (!(val6 == that.val6)) { + return false; + } + if (!(key7 == that.key7)) { + return false; + } + if (!(val7 == that.val7)) { + return false; + } + + return true; + } + + } + + private static final class Map7To1Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactMixedMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final CompactMapNode node1; + + Map7To1Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final CompactMapNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 15; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 7; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, key6, val6, key7, val7, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val, key7, val7, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, key6, val6, key7, val7, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, key6, val6, key7, val7, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key, val, key7, val7, node1); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key, val, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + key6, val6, key7, val7, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + key6, val6, key7, val7, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + key6, val6, key7, val7, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + key6, val6, key7, val7, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key6, val6, key7, val7, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key7, val7, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + final int val = node.getValue(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key, val, key5, val5, key6, val6, key7, val7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key, val, key6, val6, key7, val7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key, val, key7, val7); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + result = prime * result + (int) key5; + result = prime * result + (int) val5; + result = prime * result + (int) key6; + result = prime * result + (int) val6; + result = prime * result + (int) key7; + result = prime * result + (int) val7; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map7To1Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map7To1Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(val5 == that.val5)) { + return false; + } + if (!(key6 == that.key6)) { + return false; + } + if (!(val6 == that.val6)) { + return false; + } + if (!(key7 == that.key7)) { + return false; + } + if (!(val7 == that.val7)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Map8To0Node_5Bits_Spec0To8_IntKey_IntValue + extends CompactValuesOnlyMapNode { + + private final int key1; + private final int val1; + private final int key2; + private final int val2; + private final int key3; + private final int val3; + private final int key4; + private final int val4; + private final int key5; + private final int val5; + private final int key6; + private final int val6; + private final int key7; + private final int val7; + private final int key8; + private final int val8; + + Map8To0Node_5Bits_Spec0To8_IntKey_IntValue(final AtomicReference mutator, + final int nodeMap, final int dataMap, final int key1, final int val1, final int key2, + final int val2, final int key3, final int val3, final int key4, final int val4, + final int key5, final int val5, final int key6, final int val6, final int key7, + final int val7, final int key8, final int val8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.val1 = val1; + this.key2 = key2; + this.val2 = val2; + this.key3 = key3; + this.val3 = val3; + this.key4 = key4; + this.val4 = val4; + this.key5 = key5; + this.val5 = val5; + this.key6 = key6; + this.val6 = val6; + this.key7 = key7; + this.val7 = val7; + this.key8 = key8; + this.val8 = val8; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 16; + } + + @Override + Object getSlot(final int index) { + final int boundary = TUPLE_LENGTH * payloadArity(); + + if (index < boundary) { + if (index % 2 == 0) { + return getKey(index / 2); + } else { + return getValue(index / 2); + } + } else { + return getNode(index - boundary); + } + } + + @Override + CompactMapNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getValue(int index) { + switch (index) { + case 0: + return val1; + case 1: + return val2; + case 2: + return val3; + case 3: + return val4; + case 4: + return val5; + case 5: + return val6; + case 6: + return val7; + case 7: + return val8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + Map.Entry getKeyValueEntry(int index) { + switch (index) { + case 0: + return (java.util.Map.Entry) entryOf(key1, val1); + case 1: + return (java.util.Map.Entry) entryOf(key2, val2); + case 2: + return (java.util.Map.Entry) entryOf(key3, val3); + case 3: + return (java.util.Map.Entry) entryOf(key4, val4); + case 4: + return (java.util.Map.Entry) entryOf(key5, val5); + case 5: + return (java.util.Map.Entry) entryOf(key6, val6); + case 6: + return (java.util.Map.Entry) entryOf(key7, val7); + case 7: + return (java.util.Map.Entry) entryOf(key8, val8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 8; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactMapNode copyAndSetValue(AtomicReference mutator, final int bitpos, + final int val) { + final int idx = dataIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (idx) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val, + key5, val5, key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val, key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val, key7, val7, key8, val8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val, key8, val8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key, final int val) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, val, key1, val1, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key, val, key2, val2, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key, val, key3, val3, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key, val, + key4, val4, key5, val5, key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key, val, key5, val5, key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key, val, key6, val6, key7, val7, key8, val8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key, val, key7, val7, key8, val8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key, val, key8, val8); + case 8: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7, key8, val8, key, val); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, val5, + key6, val6, key7, val7, key8, val8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, val5, + key6, val6, key7, val7, key8, val8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, val5, + key6, val6, key7, val7, key8, val8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, val5, + key6, val6, key7, val7, key8, val8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key6, val6, key7, val7, key8, val8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key7, val7, key8, val8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key8, val8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, val4, + key5, val5, key6, val6, key7, val7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactMapNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, val2, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key3, val3, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key4, val4, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key5, + val5, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key6, val6, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key7, val7, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key8, val8, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, val1, key2, val2, key3, val3, key4, + val4, key5, val5, key6, val6, key7, val7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactMapNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactMapNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) val1; + result = prime * result + (int) key2; + result = prime * result + (int) val2; + result = prime * result + (int) key3; + result = prime * result + (int) val3; + result = prime * result + (int) key4; + result = prime * result + (int) val4; + result = prime * result + (int) key5; + result = prime * result + (int) val5; + result = prime * result + (int) key6; + result = prime * result + (int) val6; + result = prime * result + (int) key7; + result = prime * result + (int) val7; + result = prime * result + (int) key8; + result = prime * result + (int) val8; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Map8To0Node_5Bits_Spec0To8_IntKey_IntValue that = + (Map8To0Node_5Bits_Spec0To8_IntKey_IntValue) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(val1 == that.val1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(val2 == that.val2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(val3 == that.val3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(val4 == that.val4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(val5 == that.val5)) { + return false; + } + if (!(key6 == that.key6)) { + return false; + } + if (!(val6 == that.val6)) { + return false; + } + if (!(key7 == that.key7)) { + return false; + } + if (!(val7 == that.val7)) { + return false; + } + if (!(key8 == that.key8)) { + return false; + } + if (!(val8 == that.val8)) { + return false; + } + + return true; + } + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieSet_5Bits_Spec0To8.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieSet_5Bits_Spec0To8.java new file mode 100644 index 0000000..2ed2e49 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieSet_5Bits_Spec0To8.java @@ -0,0 +1,17325 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.specialized; + +import java.text.DecimalFormat; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Set; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.concurrent.atomic.AtomicReference; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +public class TrieSet_5Bits_Spec0To8 implements io.usethesource.capsule.Set.Immutable { + + private static final TrieSet_5Bits_Spec0To8 EMPTY_SET = + new TrieSet_5Bits_Spec0To8(CompactSetNode.EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractSetNode rootNode; + private final int hashCode; + private final int cachedSize; + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ TrieSet_5Bits_Spec0To8(AbstractSetNode rootNode) { + this.rootNode = rootNode; + this.hashCode = hashCode(rootNode); + this.cachedSize = size(rootNode); + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + TrieSet_5Bits_Spec0To8(AbstractSetNode rootNode, int hashCode, int cachedSize) { + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final io.usethesource.capsule.Set.Immutable of() { + return TrieSet_5Bits_Spec0To8.EMPTY_SET; + } + + public static final io.usethesource.capsule.Set.Immutable of(K... keys) { + io.usethesource.capsule.Set.Immutable result = TrieSet_5Bits_Spec0To8.EMPTY_SET; + + for (final K key : keys) { + result = result.__insert(key); + } + + return result; + } + + public static final io.usethesource.capsule.Set.Transient transientOf() { + return TrieSet_5Bits_Spec0To8.EMPTY_SET.asTransient(); + } + + public static final io.usethesource.capsule.Set.Transient transientOf(K... keys) { + final io.usethesource.capsule.Set.Transient result = TrieSet_5Bits_Spec0To8.EMPTY_SET + .asTransient(); + + for (final K key : keys) { + result.__insert(key); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator it = keyIterator(); it.hasNext(); ) { + final K key = it.next(); + + hash += key.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + private static int hashCode(AbstractSetNode rootNode) { + int hash = 0; + + for (Iterator it = new SetKeyIterator<>(rootNode); it.hasNext(); ) { + hash += it.next().hashCode(); + } + + return hash; + } + + private static int size(AbstractSetNode rootNode) { + int size = 0; + + for (Iterator it = new SetKeyIterator<>(rootNode); it.hasNext(); it.next()) { + size += 1; + } + + return size; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean contains(final Object o) { + try { + final K key = (K) o; + return rootNode.contains(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + return rootNode.contains(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public K get(final Object o) { + try { + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public K getEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable __insert(final K key) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + return new TrieSet_5Bits_Spec0To8(newRootNode, hashCode + keyHash, cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Set.Immutable __insertEquivalent(final K key, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + return new TrieSet_5Bits_Spec0To8(newRootNode, hashCode + keyHash, cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Set.Immutable __insertAll(final Set set) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__insertAll(set); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Set.Immutable __insertAllEquivalent(final Set set, + final Comparator cmp) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__insertAllEquivalent(set, cmp); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Set.Immutable __remove(final K key) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + return new TrieSet_5Bits_Spec0To8(newRootNode, hashCode - keyHash, cachedSize - 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Set.Immutable __removeEquivalent(final K key, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + return new TrieSet_5Bits_Spec0To8(newRootNode, hashCode - keyHash, cachedSize - 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Set.Immutable __removeAll(final Set set) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__removeAll(set); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Set.Immutable __removeAllEquivalent(final Set set, + final Comparator cmp) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__removeAllEquivalent(set, cmp); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Set.Immutable __retainAll(final Set set) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__retainAll(set); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Set.Immutable __retainAllEquivalent( + final io.usethesource.capsule.Set.Transient transientSet, + final Comparator cmp) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__retainAllEquivalent(transientSet, cmp); + return tmpTransient.freeze(); + } + + @Override + public boolean add(final K key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean addAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean remove(final Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean removeAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean retainAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean containsAll(final Collection c) { + for (Object item : c) { + if (!contains(item)) { + return false; + } + } + return true; + } + + @Override + public boolean containsAllEquivalent(final Collection c, final Comparator cmp) { + for (Object item : c) { + if (!containsEquivalent(item, cmp)) { + return false; + } + } + return true; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator iterator() { + return keyIterator(); + } + + @Override + public Iterator keyIterator() { + return new SetKeyIterator<>(rootNode); + } + + @Override + public Object[] toArray() { + Object[] array = new Object[cachedSize]; + + int idx = 0; + for (K key : this) { + array[idx++] = key; + } + + return array; + } + + @Override + public T[] toArray(final T[] a) { + List list = new ArrayList(cachedSize); + + for (K key : this) { + list.add(key); + } + + return list.toArray(a); + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieSet_5Bits_Spec0To8) { + TrieSet_5Bits_Spec0To8 that = (TrieSet_5Bits_Spec0To8) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Set) { + Set that = (Set) other; + + if (this.size() != that.size()) { + return false; + } + + return containsAll(that); + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public String toString() { + String body = stream().map(k -> k.toString()).reduce((o1, o2) -> String.join(", ", o1, o2)) + .orElse(""); + return String.format("{%s}", body); + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public io.usethesource.capsule.Set.Transient asTransient() { + return new TransientTrieSet_5Bits_Spec0To8(this); + } + + /* + * For analysis purposes only. + * + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ AbstractSetNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator> nodeIterator() { + return new TrieSet_5Bits_Spec0To8NodeIterator<>(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator> it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. Payload X Node + */ + protected int[][] arityCombinationsHistogram() { + final Iterator> it = nodeIterator(); + final int[][] sumArityCombinations = new int[33][33]; + + while (it.hasNext()) { + final AbstractSetNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[33]; + + final int maxArity = 32; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[33]; + for (int cumsum = 0, i = 0; i < 33; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 33; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + abstract static class Optional { + + private static final Optional EMPTY = new Optional() { + @Override + boolean isPresent() { + return false; + } + + @Override + Object get() { + return null; + } + }; + + static Optional empty() { + return EMPTY; + } + + static Optional of(T value) { + return new Value(value); + } + + abstract boolean isPresent(); + + abstract T get(); + + private static final class Value extends Optional { + + private final T value; + + private Value(T value) { + this.value = value; + } + + @Override + boolean isPresent() { + return true; + } + + @Override + T get() { + return value; + } + } + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ static final class SetResult { + + private K replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(K replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static SetResult unchanged() { + return new SetResult<>(); + } + + private SetResult() { + } + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public K getReplacedValue() { + return replacedValue; + } + } + + protected static interface INode { + + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ static abstract class AbstractSetNode + implements INode, Iterable { + + static final int TUPLE_LENGTH = 1; + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ abstract boolean contains(final K key, final int keyHash, + final int shift); + + abstract boolean contains(final K key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final K key, final int keyHash, final int shift); + + abstract Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp); + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ abstract CompactSetNode updated(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetResult details); + + abstract CompactSetNode updated(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetResult details, + final Comparator cmp); + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ abstract CompactSetNode removed(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetResult details); + + abstract CompactSetNode removed(final AtomicReference mutator, final K key, + final int keyHash, final int shift, final SetResult details, + final Comparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractSetNode getNode(final int index); + + @Deprecated + Iterator> nodeIterator() { + return new Iterator>() { + + int nextIndex = 0; + final int nodeArity = AbstractSetNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractSetNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractSetNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract K getKey(final int index); + + @Deprecated + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + public /* protected */ int size() { + final Iterator it = new SetKeyIterator<>(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + + @Override + public Iterator iterator() { + return new SetKeyIterator<>(this); + } + + @Override + public Spliterator spliterator() { + return Spliterators.spliteratorUnknownSize(iterator(), Spliterator.DISTINCT); + } + + public Stream stream() { + return StreamSupport.stream(spliterator(), false); + } + } + + protected static abstract class CompactSetNode extends AbstractSetNode { + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return (int) (1 << mask); + } + + abstract int nodeMap(); + + abstract int dataMap(); + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactSetNode getNode(final int index); + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactSetNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final K key); + + abstract CompactSetNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos); + + abstract CompactSetNode copyAndSetNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node); + + abstract CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node); + + abstract CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node); + + CompactSetNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + static final CompactSetNode mergeTwoKeyValPairs(final K key0, final int keyHash0, + final K key1, final int keyHash1, final int shift) { + assert !(key0.equals(key1)); + + if (shift >= HASH_CODE_LENGTH) { + // throw new + // IllegalStateException("Hash collision not yet fixed."); + return new HashCollisionSetNode_5Bits_Spec0To8<>(keyHash0, (K[]) new Object[]{key0, key1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int dataMap = (int) (bitpos(mask0) | bitpos(mask1)); + + if (mask0 < mask1) { + return nodeOf(null, (int) 0, dataMap, key0, key1); + } else { + return nodeOf(null, (int) 0, dataMap, key1, key0); + } + } else { + final CompactSetNode node = + mergeTwoKeyValPairs(key0, keyHash0, key1, keyHash1, shift + BIT_PARTITION_SIZE); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf(null, nodeMap, (int) 0, node); + } + } + + static final CompactSetNode EMPTY_NODE; + + static { + + EMPTY_NODE = new Set0To0Node_5Bits_Spec0To8<>(null, (int) 0, (int) 0); + + } + + ; + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final Object[] nodes) { + return new BitmapIndexedSetNode<>(mutator, nodeMap, dataMap, nodes); + } + + static final CompactSetNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap) { + return EMPTY_NODE; + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactSetNode node1) { + return new Set0To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactSetNode node1, + final CompactSetNode node2) { + return new Set0To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3) { + return new Set0To3Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2, node3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4) { + return new Set0To4Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2, node3, + node4); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5) { + return new Set0To5Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2, node3, node4, + node5); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5, final CompactSetNode node6) { + return new Set0To6Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2, node3, node4, + node5, node6); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5, final CompactSetNode node6, + final CompactSetNode node7) { + return new Set0To7Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2, node3, node4, + node5, node6, node7); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5, final CompactSetNode node6, final CompactSetNode node7, + final CompactSetNode node8) { + return new Set0To8Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, node1, node2, node3, node4, + node5, node6, node7, node8); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5, final CompactSetNode node6, final CompactSetNode node7, + final CompactSetNode node8, final CompactSetNode node9) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1) { + return new Set1To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final CompactSetNode node1) { + return new Set1To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final CompactSetNode node1, + final CompactSetNode node2) { + return new Set1To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, node1, node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3) { + return new Set1To3Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, node1, node2, node3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4) { + return new Set1To4Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, node1, node2, node3, + node4); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5) { + return new Set1To5Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, node1, node2, node3, + node4, node5); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5, final CompactSetNode node6) { + return new Set1To6Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, node1, node2, node3, + node4, node5, node6); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5, final CompactSetNode node6, + final CompactSetNode node7) { + return new Set1To7Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, node1, node2, node3, + node4, node5, node6, node7); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5, final CompactSetNode node6, final CompactSetNode node7, + final CompactSetNode node8) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2) { + return new Set2To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, + final CompactSetNode node1) { + return new Set2To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, + final CompactSetNode node1, final CompactSetNode node2) { + return new Set2To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, node1, node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, + final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + return new Set2To3Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, node1, node2, + node3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4) { + return new Set2To4Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, node1, node2, + node3, node4); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4, final CompactSetNode node5) { + return new Set2To5Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, node1, node2, + node3, node4, node5); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6) { + return new Set2To6Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, node1, node2, + node3, node4, node5, node6); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4, final CompactSetNode node5, final CompactSetNode node6, + final CompactSetNode node7) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3) { + return new Set3To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final CompactSetNode node1) { + return new Set3To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final CompactSetNode node1, final CompactSetNode node2) { + return new Set3To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, node1, + node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + return new Set3To3Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, node1, + node2, node3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4) { + return new Set3To4Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, node1, + node2, node3, node4); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4, final CompactSetNode node5) { + return new Set3To5Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, node1, + node2, node3, node4, node5); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, node6, node5, node4, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4) { + return new Set4To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final CompactSetNode node1) { + return new Set4To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final CompactSetNode node1, final CompactSetNode node2) { + return new Set4To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + node1, node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + return new Set4To3Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + node1, node2, node3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4) { + return new Set4To4Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + node1, node2, node3, node4); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, key4, node5, node4, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5) { + return new Set5To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + key5); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final CompactSetNode node1) { + return new Set5To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + key5, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final CompactSetNode node1, final CompactSetNode node2) { + return new Set5To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + key5, node1, node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + return new Set5To3Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + key5, node1, node2, node3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, key4, key5, node4, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final K key6) { + return new Set6To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + key5, key6); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final K key6, final CompactSetNode node1) { + return new Set6To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + key5, key6, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final K key6, final CompactSetNode node1, + final CompactSetNode node2) { + return new Set6To2Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + key5, key6, node1, node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final K key6, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, key4, key5, key6, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final K key6, final K key7) { + return new Set7To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + key5, key6, key7); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final K key6, final K key7, final CompactSetNode node1) { + return new Set7To1Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + key5, key6, key7, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final K key6, final K key7, final CompactSetNode node1, + final CompactSetNode node2) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, key4, key5, key6, key7, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final K key6, final K key7, final K key8) { + return new Set8To0Node_5Bits_Spec0To8<>(mutator, nodeMap, dataMap, key1, key2, key3, key4, + key5, key6, key7, key8); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final K key6, final K key7, final K key8, + final CompactSetNode node1) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, key4, key5, key6, key7, key8, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, + final int nodeMap, final int dataMap, final K key1, final K key2, final K key3, + final K key4, final K key5, final K key6, final K key7, final K key8, final K key9) { + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, key4, key5, key6, key7, key8, key9}); + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + CompactSetNode nodeAt(final int bitpos) { + return getNode(nodeIndex(bitpos)); + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + @Override + public /* protected */ boolean contains(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index).equals(key); + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).contains(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return false; + } + + @Override + boolean contains(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return cmp.compare(getKey(index), key) == 0; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).contains(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index).equals(key)) { + return Optional.of(getKey(index)); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractSetNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (cmp.compare(getKey(index), key) == 0) { + return Optional.of(getKey(index)); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractSetNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return Optional.empty(); + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + @Override + public /* protected */ CompactSetNode updated(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (currentKey.equals(key)) { + return this; + } else { + final CompactSetNode subNodeNew = mergeTwoKeyValPairs(currentKey, + transformHashCode(currentKey.hashCode()), key, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.updated(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key); + } + } + + @Override + CompactSetNode updated(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final K currentKey = getKey(dataIndex); + + if (cmp.compare(currentKey, key) == 0) { + return this; + } else { + final CompactSetNode subNodeNew = mergeTwoKeyValPairs(currentKey, + transformHashCode(currentKey.hashCode()), key, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.updated(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key); + } + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + @Override + public /* protected */ CompactSetNode removed(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex).equals(key)) { + details.modified(); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactSetNode.nodeOf(mutator, (int) 0, newDataMap, getKey(1)); + } else { + return CompactSetNode.nodeOf(mutator, (int) 0, newDataMap, getKey(0)); + } + } else if (this.arity() == 9) { + return removeInplaceValueAndConvertToSpecializedNode(mutator, bitpos); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + details.modified(); + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + @Override + CompactSetNode removed(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (cmp.compare(getKey(dataIndex), key) == 0) { + details.modified(); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactSetNode.nodeOf(mutator, (int) 0, newDataMap, getKey(1)); + } else { + return CompactSetNode.nodeOf(mutator, (int) 0, newDataMap, getKey(0)); + } + } else if (this.arity() == 9) { + return removeInplaceValueAndConvertToSpecializedNode(mutator, bitpos); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + details.modified(); + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = (int) (map >> 1); + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d<#%d>", pos, Objects.hashCode(getKey(i)))); + + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedSetNode extends CompactSetNode { + + private final int nodeMap; + private final int dataMap; + + CompactMixedSetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + protected static abstract class CompactNodesOnlySetNode extends CompactSetNode { + + private final int nodeMap; + + CompactNodesOnlySetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return 0; + } + + } + + protected static abstract class CompactValuesOnlySetNode extends CompactSetNode { + + private final int dataMap; + + CompactValuesOnlySetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return 0; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + protected static abstract class CompactEmptySetNode extends CompactSetNode { + + CompactEmptySetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + } + + @Override + public int nodeMap() { + return 0; + } + + @Override + public int dataMap() { + return 0; + } + + } + + private static final class BitmapIndexedSetNode extends CompactMixedSetNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedSetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + super(mutator, nodeMap, dataMap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + + assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < TUPLE_LENGTH * payloadArity(); i++) { + assert ((nodes[i] instanceof CompactSetNode) == false); + } + for (int i = TUPLE_LENGTH * payloadArity(); i < nodes.length; i++) { + assert ((nodes[i] instanceof CompactSetNode) == true); + } + } + + assert arity() > 8; + assert nodeInvariant(); + } + + @Override + K getKey(final int index) { + return (K) nodes[TUPLE_LENGTH * index]; + } + + @Override + CompactSetNode getNode(final int index) { + return (CompactSetNode) nodes[nodes.length - 1 - index]; + } + + @Override + boolean hasPayload() { + return dataMap() != 0; + } + + @Override + int payloadArity() { + return java.lang.Integer.bitCount(dataMap()); + } + + @Override + boolean hasNodes() { + return nodeMap() != 0; + } + + @Override + int nodeArity() { + return java.lang.Integer.bitCount(nodeMap()); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + ((int) dataMap()); + result = prime * result + ((int) dataMap()); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedSetNode that = (BitmapIndexedSetNode) other; + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + if (!Arrays.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactSetNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(bitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactSetNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length + 1]; + + // copy 'src' and insert 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + System.arraycopy(src, idx, dst, idx + 1, src.length - idx); + + return nodeOf(mutator, nodeMap(), (int) (dataMap() | bitpos), dst); + } + + @Override + CompactSetNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length - 1]; + + // copy 'src' and remove 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 1, dst, idx, src.length - idx - 1); + + return nodeOf(mutator, nodeMap(), (int) (dataMap() ^ bitpos), dst); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 1]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 1, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 1, dst, idxNew + 1, src.length - idxNew - 1); + + return nodeOf(mutator, (int) (nodeMap() | bitpos), (int) (dataMap() ^ bitpos), dst); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 1]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = node.getKey(0); + System.arraycopy(src, idxNew, dst, idxNew + 1, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 1, src.length - idxOld - 1); + + return nodeOf(mutator, (int) (nodeMap() ^ bitpos), (int) (dataMap() | bitpos), dst); + } + + @Override + CompactSetNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (payloadArity()) { // 0 <= payloadArity <= 9 // or ts.nMax + case 1: { + + switch (valIndex) { + case 0: { + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + final CompactSetNode node3 = getNode(2); + final CompactSetNode node4 = getNode(3); + final CompactSetNode node5 = getNode(4); + final CompactSetNode node6 = getNode(5); + final CompactSetNode node7 = getNode(6); + final CompactSetNode node8 = getNode(7); + + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node7, + node8); + + } + case 2: { + K key1; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + break; + } + case 1: { + + key1 = getKey(0); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + final CompactSetNode node3 = getNode(2); + final CompactSetNode node4 = getNode(3); + final CompactSetNode node5 = getNode(4); + final CompactSetNode node6 = getNode(5); + final CompactSetNode node7 = getNode(6); + + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, node6, + node7); + + } + case 3: { + K key1; + K key2; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + final CompactSetNode node3 = getNode(2); + final CompactSetNode node4 = getNode(3); + final CompactSetNode node5 = getNode(4); + final CompactSetNode node6 = getNode(5); + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, node5, + node6); + + } + case 4: { + K key1; + K key2; + K key3; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + key3 = getKey(3); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + key3 = getKey(3); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(3); + + break; + } + case 3: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + final CompactSetNode node3 = getNode(2); + final CompactSetNode node4 = getNode(3); + final CompactSetNode node5 = getNode(4); + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node4, + node5); + + } + case 5: { + K key1; + K key2; + K key3; + K key4; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(3); + + key4 = getKey(4); + + break; + } + case 3: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(4); + + break; + } + case 4: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + final CompactSetNode node3 = getNode(2); + final CompactSetNode node4 = getNode(3); + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node3, + node4); + + } + case 6: { + K key1; + K key2; + K key3; + K key4; + K key5; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + break; + } + case 3: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(4); + + key5 = getKey(5); + + break; + } + case 4: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(5); + + break; + } + case 5: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + final CompactSetNode node3 = getNode(2); + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node2, + node3); + + } + case 7: { + K key1; + K key2; + K key3; + K key4; + K key5; + K key6; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + break; + } + case 3: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + break; + } + case 4: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(5); + + key6 = getKey(6); + + break; + } + case 5: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(6); + + break; + } + case 6: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(5); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node1, + node2); + + } + case 8: { + K key1; + K key2; + K key3; + K key4; + K key5; + K key6; + K key7; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + break; + } + case 3: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + break; + } + case 4: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + break; + } + case 5: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(6); + + key7 = getKey(7); + + break; + } + case 6: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(5); + + key7 = getKey(7); + + break; + } + case 7: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(5); + + key7 = getKey(6); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, node1); + + } + case 9: { + K key1; + K key2; + K key3; + K key4; + K key5; + K key6; + K key7; + K key8; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 3: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 4: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 5: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(6); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 6: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(5); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 7: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(5); + + key7 = getKey(6); + + key8 = getKey(8); + + break; + } + case 8: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(5); + + key7 = getKey(6); + + key8 = getKey(7); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, key8); + + } + default: + throw new IllegalStateException("Index out of range."); + } + } + } + + private static final class HashCollisionSetNode_5Bits_Spec0To8 extends CompactSetNode { + + private final K[] keys; + + private final int hash; + + HashCollisionSetNode_5Bits_Spec0To8(final int hash, final K[] keys) { + this.keys = keys; + + this.hash = hash; + + assert payloadArity() >= 2; + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + @Override + public /* protected */ boolean contains(final K key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (K k : keys) { + if (k.equals(key)) { + return true; + } + } + } + return false; + } + + @Override + boolean contains(final K key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (K k : keys) { + if (cmp.compare(k, key) == 0) { + return true; + } + } + } + return false; + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (key.equals(_key)) { + return Optional.of(_key); + } + } + return Optional.empty(); + } + + @Override + Optional findByKey(final K key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final K _key = keys[i]; + if (cmp.compare(key, _key) == 0) { + return Optional.of(_key); + } + } + return Optional.empty(); + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + @Override + public /* protected */ CompactSetNode updated(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + return this; + } + } + + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + details.modified(); + return new HashCollisionSetNode_5Bits_Spec0To8<>(keyHash, keysNew); + } + + @Override + CompactSetNode updated(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + return this; + } + } + + final K[] keysNew = (K[]) new Object[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + details.modified(); + return new HashCollisionSetNode_5Bits_Spec0To8<>(keyHash, keysNew); + } + + /* + * TODO: visibility is currently public to allow set-multimap experiments. Must be set back to + * `protected` when experiments are finished. + */ + @Override + public /* protected */ CompactSetNode removed(final AtomicReference mutator, + final K key, final int keyHash, final int shift, final SetResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx].equals(key)) { + details.modified(); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + + return CompactSetNode.nodeOf(mutator).updated(mutator, theOtherKey, keyHash, 0, + details); + } else { + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + return new HashCollisionSetNode_5Bits_Spec0To8<>(keyHash, keysNew); + } + } + } + return this; + } + + @Override + CompactSetNode removed(final AtomicReference mutator, final K key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (cmp.compare(keys[idx], key) == 0) { + details.modified(); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final K theOtherKey = (idx == 0) ? keys[1] : keys[0]; + + return CompactSetNode.nodeOf(mutator).updated(mutator, theOtherKey, keyHash, 0, + details, cmp); + } else { + final K[] keysNew = (K[]) new Object[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + return new HashCollisionSetNode_5Bits_Spec0To8<>(keyHash, keysNew); + } + } + } + return this; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return keys.length; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + int arity() { + return payloadArity(); + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + K getKey(final int index) { + return keys[index]; + } + + @Override + public CompactSetNode getNode(int index) { + throw new IllegalStateException("Is leaf node."); + } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + hash; + result = prime * result + Arrays.hashCode(keys); + return result; + } + + @Override + public boolean equals(Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + HashCollisionSetNode_5Bits_Spec0To8 that = (HashCollisionSetNode_5Bits_Spec0To8) other; + + if (hash != that.hash) { + return false; + } + + if (arity() != that.arity()) { + return false; + } + + /* + * Linear scan for each key, because of arbitrary element order. + */ + outerLoop: + for (int i = 0; i < that.payloadArity(); i++) { + final Object otherKey = that.getKey(i); + + for (int j = 0; j < keys.length; j++) { + final K key = keys[j]; + + if (key.equals(otherKey)) { + continue outerLoop; + } + } + return false; + + } + + return true; + } + + @Override + CompactSetNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final K key) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactSetNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + int nodeMap() { + throw new UnsupportedOperationException(); + } + + @Override + int dataMap() { + throw new UnsupportedOperationException(); + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractSetNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractSetNode[] nodes = new AbstractSetNode[MAX_DEPTH]; + + AbstractSetIterator(AbstractSetNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractSetNode nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetKeyIterator extends AbstractSetIterator implements Iterator { + + SetKeyIterator(AbstractSetNode rootNode) { + super(rootNode); + } + + @Override + public K next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieSet_5Bits_Spec0To8NodeIterator + implements Iterator> { + + final Deque>> nodeIteratorStack; + + TrieSet_5Bits_Spec0To8NodeIterator(AbstractSetNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractSetNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractSetNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieSet_5Bits_Spec0To8 implements + io.usethesource.capsule.Set.Transient { + + final private AtomicReference mutator; + private AbstractSetNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieSet_5Bits_Spec0To8(TrieSet_5Bits_Spec0To8 trieSet_5Bits_Spec0To8) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieSet_5Bits_Spec0To8.rootNode; + this.hashCode = trieSet_5Bits_Spec0To8.hashCode; + this.cachedSize = trieSet_5Bits_Spec0To8.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator it = keyIterator(); it.hasNext(); ) { + final K key = it.next(); + + hash += key.hashCode(); + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean add(final K key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean addAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean remove(final Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean removeAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean retainAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(final Object o) { + try { + final K key = (K) o; + return rootNode.contains(key, transformHashCode(key.hashCode()), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + return rootNode.contains(key, transformHashCode(key.hashCode()), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public K get(final Object o) { + try { + final K key = (K) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key.hashCode()), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public K getEquivalent(final Object o, final Comparator cmp) { + try { + final K key = (K) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key.hashCode()), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public boolean __insert(final K key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + + rootNode = newRootNode; + hashCode += keyHash; + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean __insertEquivalent(final K key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + + rootNode = newRootNode; + hashCode += keyHash; + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean __insertAll(final Set set) { + boolean modified = false; + + for (final K key : set) { + modified |= this.__insert(key); + } + + return modified; + } + + @Override + public boolean __insertAllEquivalent(final Set set, final Comparator cmp) { + boolean modified = false; + + for (final K key : set) { + modified |= this.__insertEquivalent(key, cmp); + } + + return modified; + } + + @Override + public boolean __remove(final K key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + rootNode = newRootNode; + hashCode = hashCode - keyHash; + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return false; + } + + @Override + public boolean __removeEquivalent(final K key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + rootNode = newRootNode; + hashCode = hashCode - keyHash; + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return false; + } + + @Override + public boolean __removeAll(final Set set) { + boolean modified = false; + + for (final K key : set) { + modified |= this.__remove(key); + } + + return modified; + } + + @Override + public boolean __removeAllEquivalent(final Set set, final Comparator cmp) { + boolean modified = false; + + for (final K key : set) { + modified |= this.__removeEquivalent(key, cmp); + } + + return modified; + } + + @Override + public boolean __retainAll(final Set set) { + boolean modified = false; + + Iterator thisIterator = iterator(); + while (thisIterator.hasNext()) { + if (!set.contains(thisIterator.next())) { + thisIterator.remove(); + modified = true; + } + } + + return modified; + } + + @Override + public boolean __retainAllEquivalent( + final io.usethesource.capsule.Set.Transient transientSet, + final Comparator cmp) { + boolean modified = false; + + Iterator thisIterator = iterator(); + while (thisIterator.hasNext()) { + if (!transientSet.containsEquivalent(thisIterator.next(), cmp)) { + thisIterator.remove(); + modified = true; + } + } + + return modified; + } + + @Override + public boolean containsAll(Collection c) { + for (Object item : c) { + if (!contains(item)) { + return false; + } + } + return true; + } + + @Override + public boolean containsAllEquivalent(Collection c, Comparator cmp) { + for (Object item : c) { + if (!containsEquivalent(item, cmp)) { + return false; + } + } + return true; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator iterator() { + return keyIterator(); + } + + @Override + public Iterator keyIterator() { + return new TransientSetKeyIterator<>(this); + } + + public static class TransientSetKeyIterator extends SetKeyIterator { + + final TransientTrieSet_5Bits_Spec0To8 collection; + K lastKey; + + public TransientSetKeyIterator(final TransientTrieSet_5Bits_Spec0To8 collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public K next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(lastKey); + } + } + + @Override + public Object[] toArray() { + Object[] array = new Object[cachedSize]; + + int idx = 0; + for (K key : this) { + array[idx++] = key; + } + + return array; + } + + @Override + public T[] toArray(final T[] a) { + List list = new ArrayList(cachedSize); + + for (K key : this) { + list.add(key); + } + + return list.toArray(a); + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieSet_5Bits_Spec0To8) { + TransientTrieSet_5Bits_Spec0To8 that = (TransientTrieSet_5Bits_Spec0To8) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Set) { + Set that = (Set) other; + + if (this.size() != that.size()) { + return false; + } + + return containsAll(that); + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public io.usethesource.capsule.Set.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieSet_5Bits_Spec0To8(rootNode, hashCode, cachedSize); + } + } + + private static final class Set0To0Node_5Bits_Spec0To8 extends CompactEmptySetNode { + + Set0To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + super(mutator, nodeMap, dataMap); + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return false; + } + + @Override + int slotArity() { + return 0; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_EMPTY; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + int result = 1; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + return true; + } + + } + + private static final class Set0To1Node_5Bits_Spec0To8 extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + + Set0To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 1; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To1Node_5Bits_Spec0To8 that = (Set0To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set0To2Node_5Bits_Spec0To8 extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set0To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 2; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To2Node_5Bits_Spec0To8 that = (Set0To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set0To3Node_5Bits_Spec0To8 extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + + Set0To3Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 3; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To3Node_5Bits_Spec0To8 that = (Set0To3Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Set0To4Node_5Bits_Spec0To8 extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + + Set0To4Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To4Node_5Bits_Spec0To8 that = (Set0To4Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Set0To5Node_5Bits_Spec0To8 extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + + Set0To5Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To5Node_5Bits_Spec0To8 that = (Set0To5Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Set0To6Node_5Bits_Spec0To8 extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + private final CompactSetNode node6; + + Set0To6Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 6; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To6Node_5Bits_Spec0To8 that = (Set0To6Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + + return true; + } + + } + + private static final class Set0To7Node_5Bits_Spec0To8 extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + private final CompactSetNode node6; + private final CompactSetNode node7; + + Set0To7Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6, final CompactSetNode node7) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + case 6: + return node7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 7; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, node7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, node7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, node7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, node7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, node7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + result = prime * result + node7.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To7Node_5Bits_Spec0To8 that = (Set0To7Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + if (!(node7.equals(that.node7))) { + return false; + } + + return true; + } + + } + + private static final class Set0To8Node_5Bits_Spec0To8 extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + private final CompactSetNode node6; + private final CompactSetNode node7; + private final CompactSetNode node8; + + Set0To8Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6, final CompactSetNode node7, + final CompactSetNode node8) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + case 6: + return node7; + case 7: + return node8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 8; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, node7, + node8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, node7, + node8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, node7, + node8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, node7, + node8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, node7, + node8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, node7, + node8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node, + node8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, + node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + result = prime * result + node7.hashCode(); + result = prime * result + node8.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To8Node_5Bits_Spec0To8 that = (Set0To8Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + if (!(node7.equals(that.node7))) { + return false; + } + if (!(node8.equals(that.node8))) { + return false; + } + + return true; + } + + } + + private static final class Set1To0Node_5Bits_Spec0To8 extends CompactValuesOnlySetNode { + + private final K key1; + + Set1To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 1; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To0Node_5Bits_Spec0To8 that = (Set1To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + + return true; + } + + } + + private static final class Set1To1Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final CompactSetNode node1; + + Set1To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 2; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To1Node_5Bits_Spec0To8 that = (Set1To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set1To2Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set1To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final CompactSetNode node1, + final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 3; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To2Node_5Bits_Spec0To8 that = (Set1To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set1To3Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + + Set1To3Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To3Node_5Bits_Spec0To8 that = (Set1To3Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Set1To4Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + + Set1To4Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To4Node_5Bits_Spec0To8 that = (Set1To4Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Set1To5Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + + Set1To5Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To5Node_5Bits_Spec0To8 that = (Set1To5Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Set1To6Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + private final CompactSetNode node6; + + Set1To6Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5, final CompactSetNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 6; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To6Node_5Bits_Spec0To8 that = (Set1To6Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + + return true; + } + + } + + private static final class Set1To7Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + private final CompactSetNode node6; + private final CompactSetNode node7; + + Set1To7Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5, final CompactSetNode node6, + final CompactSetNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + case 6: + return node7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 7; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node3, node4, node5, node6, + node7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node4, node5, node6, + node7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node, node5, node6, + node7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node, node6, + node7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, node, + node7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, node6, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7); + case 7: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node3, node4, node5, node6, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node4, node5, node6, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node5, node6, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, node6, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, node5, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, node5, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + result = prime * result + node7.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To7Node_5Bits_Spec0To8 that = (Set1To7Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + if (!(node7.equals(that.node7))) { + return false; + } + + return true; + } + + } + + private static final class Set2To0Node_5Bits_Spec0To8 extends CompactValuesOnlySetNode { + + private final K key1; + private final K key2; + + Set2To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 2; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To0Node_5Bits_Spec0To8 that = (Set2To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + + return true; + } + + } + + private static final class Set2To1Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final CompactSetNode node1; + + Set2To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 3; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To1Node_5Bits_Spec0To8 that = (Set2To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set2To2Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set2To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final CompactSetNode node1, + final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To2Node_5Bits_Spec0To8 that = (Set2To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set2To3Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + + Set2To3Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To3Node_5Bits_Spec0To8 that = (Set2To3Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Set2To4Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + + Set2To4Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To4Node_5Bits_Spec0To8 that = (Set2To4Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Set2To5Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + + Set2To5Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To5Node_5Bits_Spec0To8 that = (Set2To5Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Set2To6Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + private final CompactSetNode node6; + + Set2To6Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5, final CompactSetNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 6; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node4, + node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node3, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node, node4, node5, + node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node, node5, + node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, node, + node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node, node2, node3, node4, + node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node, node3, node4, + node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node, node4, + node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node, + node5, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node5, + node, node6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node2, node3, node4, + node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node3, node4, + node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node, node4, + node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node, + node5, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, + node, node6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node2, node3, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node3, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node4, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node4, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node4, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To6Node_5Bits_Spec0To8 that = (Set2To6Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + + return true; + } + + } + + private static final class Set3To0Node_5Bits_Spec0To8 extends CompactValuesOnlySetNode { + + private final K key1; + private final K key2; + private final K key3; + + Set3To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 3; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set3To0Node_5Bits_Spec0To8 that = (Set3To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + + return true; + } + + } + + private static final class Set3To1Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final CompactSetNode node1; + + Set3To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, + final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set3To1Node_5Bits_Spec0To8 that = (Set3To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set3To2Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set3To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final CompactSetNode node1, + final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set3To2Node_5Bits_Spec0To8 that = (Set3To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set3To3Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + + Set3To3Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set3To3Node_5Bits_Spec0To8 that = (Set3To3Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Set3To4Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + + Set3To4Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set3To4Node_5Bits_Spec0To8 that = (Set3To4Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Set3To5Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + + Set3To5Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node3, + node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node3, + node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node3, + node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node2, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node3, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node3, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node3, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node3, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set3To5Node_5Bits_Spec0To8 that = (Set3To5Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Set4To0Node_5Bits_Spec0To8 extends CompactValuesOnlySetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + + Set4To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set4To0Node_5Bits_Spec0To8 that = (Set4To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + + return true; + } + + } + + private static final class Set4To1Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final CompactSetNode node1; + + Set4To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, + final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set4To1Node_5Bits_Spec0To8 that = (Set4To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set4To2Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set4To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, + final CompactSetNode node1, final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set4To2Node_5Bits_Spec0To8 that = (Set4To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set4To3Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + + Set4To3Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, + final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node2, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node2, + node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set4To3Node_5Bits_Spec0To8 that = (Set4To3Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Set4To4Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + + Set4To4Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node2, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node2, node3, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node2, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node2, node3, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node3, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node2, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node2, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node2, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node2, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node2, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node2, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node2, + node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set4To4Node_5Bits_Spec0To8 that = (Set4To4Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Set5To0Node_5Bits_Spec0To8 extends CompactValuesOnlySetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final K key5; + + Set5To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, final K key5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + key5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set5To0Node_5Bits_Spec0To8 that = (Set5To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + + return true; + } + + } + + private static final class Set5To1Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final K key5; + private final CompactSetNode node1; + + Set5To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, final K key5, + final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + key5.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set5To1Node_5Bits_Spec0To8 that = (Set5To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set5To2Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final K key5; + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set5To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, final K key5, + final CompactSetNode node1, final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + key5.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set5To2Node_5Bits_Spec0To8 that = (Set5To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set5To3Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final K key5; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + + Set5To3Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, final K key5, + final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node1, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node1, node2, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node1, node2, + node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node1, node2, + node3); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node2, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node2, + node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node2, + node3); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node1, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node1, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node1, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node1, + node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node1, + node3); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node1, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node1, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node1, + node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node1, + node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node1, + node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + key5.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set5To3Node_5Bits_Spec0To8 that = (Set5To3Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Set6To0Node_5Bits_Spec0To8 extends CompactValuesOnlySetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final K key5; + private final K key6; + + Set6To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, final K key5, + final K key6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.key6 = key6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 6; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + key6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set6To0Node_5Bits_Spec0To8 that = (Set6To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(key6.equals(that.key6))) { + return false; + } + + return true; + } + + } + + private static final class Set6To1Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final K key5; + private final K key6; + private final CompactSetNode node1; + + Set6To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, final K key5, + final K key6, final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.key6 = key6; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 6; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + key6.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set6To1Node_5Bits_Spec0To8 that = (Set6To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(key6.equals(that.key6))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set6To2Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final K key5; + private final K key6; + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set6To2Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, final K key5, + final K key6, final CompactSetNode node1, final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.key6 = key6; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 6; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, node1, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, node1, + node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, node1, + node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, node1, + node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, node1, + node2); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node1, node, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node1, node, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node1, node, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node1, node, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node1, node, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, + node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, + node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, + node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, + node2); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, + node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, + node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, + node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, + node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, + node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + key6.hashCode(); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set6To2Node_5Bits_Spec0To8 that = (Set6To2Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(key6.equals(that.key6))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set7To0Node_5Bits_Spec0To8 extends CompactValuesOnlySetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final K key5; + private final K key6; + private final K key7; + + Set7To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, final K key5, + final K key6, final K key7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.key6 = key6; + this.key7 = key7; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 7; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, key7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, key7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, key7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, key7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, key7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, key7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, key7); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + key6.hashCode(); + result = prime * result + key7.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set7To0Node_5Bits_Spec0To8 that = (Set7To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(key6.equals(that.key6))) { + return false; + } + if (!(key7.equals(that.key7))) { + return false; + } + + return true; + } + + } + + private static final class Set7To1Node_5Bits_Spec0To8 extends CompactMixedSetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final K key5; + private final K key6; + private final K key7; + private final CompactSetNode node1; + + Set7To1Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, final K key5, + final K key6, final K key7, final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.key6 = key6; + this.key7 = key7; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 7; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, key7, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, key7, + node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, key7, + node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, key7, + node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, key7, + node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, key7, + node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, key7, + node1); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, key, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final K key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, + key7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, + key7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, + key7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, + key7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, + key7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, + key7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, + key7); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, + key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + key6.hashCode(); + result = prime * result + key7.hashCode(); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set7To1Node_5Bits_Spec0To8 that = (Set7To1Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(key6.equals(that.key6))) { + return false; + } + if (!(key7.equals(that.key7))) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set8To0Node_5Bits_Spec0To8 extends CompactValuesOnlySetNode { + + private final K key1; + private final K key2; + private final K key3; + private final K key4; + private final K key5; + private final K key6; + private final K key7; + private final K key8; + + Set8To0Node_5Bits_Spec0To8(final AtomicReference mutator, final int nodeMap, + final int dataMap, final K key1, final K key2, final K key3, final K key4, final K key5, + final K key6, final K key7, final K key8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.key6 = key6; + this.key7 = key7; + this.key8 = key8; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + K getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 8; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final K key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, key7, + key8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, key7, + key8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, key7, + key8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, key7, + key8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, key7, + key8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, key7, + key8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, key7, + key8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, key, + key8); + case 8: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, key8, + key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7, key8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7, key8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7, key8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7, key8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7, key8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7, key8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + key1.hashCode(); + result = prime * result + key2.hashCode(); + result = prime * result + key3.hashCode(); + result = prime * result + key4.hashCode(); + result = prime * result + key5.hashCode(); + result = prime * result + key6.hashCode(); + result = prime * result + key7.hashCode(); + result = prime * result + key8.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set8To0Node_5Bits_Spec0To8 that = (Set8To0Node_5Bits_Spec0To8) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1.equals(that.key1))) { + return false; + } + if (!(key2.equals(that.key2))) { + return false; + } + if (!(key3.equals(that.key3))) { + return false; + } + if (!(key4.equals(that.key4))) { + return false; + } + if (!(key5.equals(that.key5))) { + return false; + } + if (!(key6.equals(that.key6))) { + return false; + } + if (!(key7.equals(that.key7))) { + return false; + } + if (!(key8.equals(that.key8))) { + return false; + } + + return true; + } + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieSet_5Bits_Spec0To8_IntKey.java b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieSet_5Bits_Spec0To8_IntKey.java new file mode 100644 index 0000000..a169484 --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/experimental/specialized/TrieSet_5Bits_Spec0To8_IntKey.java @@ -0,0 +1,17205 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.experimental.specialized; + +import java.text.DecimalFormat; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.Iterator; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.atomic.AtomicReference; + +public class TrieSet_5Bits_Spec0To8_IntKey implements + io.usethesource.capsule.Set.Immutable { + + private static final TrieSet_5Bits_Spec0To8_IntKey EMPTY_SET = + new TrieSet_5Bits_Spec0To8_IntKey(CompactSetNode.EMPTY_NODE, 0, 0); + + private static final boolean DEBUG = false; + + private final AbstractSetNode rootNode; + private final int hashCode; + private final int cachedSize; + + TrieSet_5Bits_Spec0To8_IntKey(AbstractSetNode rootNode, int hashCode, int cachedSize) { + this.rootNode = rootNode; + this.hashCode = hashCode; + this.cachedSize = cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + public static final io.usethesource.capsule.Set.Immutable of() { + return TrieSet_5Bits_Spec0To8_IntKey.EMPTY_SET; + } + + public static final io.usethesource.capsule.Set.Immutable of(int... keys) { + io.usethesource.capsule.Set.Immutable result = TrieSet_5Bits_Spec0To8_IntKey.EMPTY_SET; + + for (final int key : keys) { + result = result.__insert(key); + } + + return result; + } + + public static final io.usethesource.capsule.Set.Transient transientOf() { + return TrieSet_5Bits_Spec0To8_IntKey.EMPTY_SET.asTransient(); + } + + public static final io.usethesource.capsule.Set.Transient transientOf(int... keys) { + final io.usethesource.capsule.Set.Transient result = + TrieSet_5Bits_Spec0To8_IntKey.EMPTY_SET.asTransient(); + + for (final int key : keys) { + result.__insert(key); + } + + return result; + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator it = keyIterator(); it.hasNext(); ) { + final int key = it.next(); + + hash += (int) key; + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + public static final int transformHashCode(final int hash) { + return hash; + } + + @Override + public boolean contains(final Object o) { + try { + final int key = (int) o; + return rootNode.contains(key, transformHashCode(key), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsEquivalent(final Object o, final Comparator cmp) { + try { + final int key = (int) o; + return rootNode.contains(key, transformHashCode(key), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public java.lang.Integer get(final Object o) { + try { + final int key = (int) o; + final Optional result = rootNode.findByKey(key, transformHashCode(key), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public java.lang.Integer getEquivalent(final Object o, final Comparator cmp) { + try { + final int key = (int) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public io.usethesource.capsule.Set.Immutable __insert(final java.lang.Integer key) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + return new TrieSet_5Bits_Spec0To8_IntKey(newRootNode, hashCode + keyHash, cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Set.Immutable __insertEquivalent( + final java.lang.Integer key, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + return new TrieSet_5Bits_Spec0To8_IntKey(newRootNode, hashCode + keyHash, cachedSize + 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Set.Immutable __insertAll( + final Set set) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__insertAll(set); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Set.Immutable __insertAllEquivalent( + final Set set, final Comparator cmp) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__insertAllEquivalent(set, cmp); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Set.Immutable __remove(final java.lang.Integer key) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + return new TrieSet_5Bits_Spec0To8_IntKey(newRootNode, hashCode - keyHash, cachedSize - 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Set.Immutable __removeEquivalent( + final java.lang.Integer key, + final Comparator cmp) { + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(null, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + return new TrieSet_5Bits_Spec0To8_IntKey(newRootNode, hashCode - keyHash, cachedSize - 1); + } + + return this; + } + + @Override + public io.usethesource.capsule.Set.Immutable __removeAll( + final Set set) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__removeAll(set); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Set.Immutable __removeAllEquivalent( + final Set set, final Comparator cmp) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__removeAllEquivalent(set, cmp); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Set.Immutable __retainAll( + final Set set) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__retainAll(set); + return tmpTransient.freeze(); + } + + @Override + public io.usethesource.capsule.Set.Immutable __retainAllEquivalent( + final io.usethesource.capsule.Set.Transient transientSet, + final Comparator cmp) { + final io.usethesource.capsule.Set.Transient tmpTransient = this.asTransient(); + tmpTransient.__retainAllEquivalent(transientSet, cmp); + return tmpTransient.freeze(); + } + + @Override + public boolean add(final java.lang.Integer key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean addAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean remove(final Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean removeAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean retainAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean containsAll(final Collection c) { + for (Object item : c) { + if (!contains(item)) { + return false; + } + } + return true; + } + + @Override + public boolean containsAllEquivalent(final Collection c, final Comparator cmp) { + for (Object item : c) { + if (!containsEquivalent(item, cmp)) { + return false; + } + } + return true; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator iterator() { + return keyIterator(); + } + + @Override + public Iterator keyIterator() { + return new SetKeyIterator(rootNode); + } + + @Override + public Object[] toArray() { + Object[] array = new Object[cachedSize]; + + int idx = 0; + for (java.lang.Integer key : this) { + array[idx++] = key; + } + + return array; + } + + @Override + public T[] toArray(final T[] a) { + List list = new ArrayList(cachedSize); + + for (java.lang.Integer key : this) { + list.add(key); + } + + return list.toArray(a); + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TrieSet_5Bits_Spec0To8_IntKey) { + TrieSet_5Bits_Spec0To8_IntKey that = (TrieSet_5Bits_Spec0To8_IntKey) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Set) { + Set that = (Set) other; + + if (this.size() != that.size()) { + return false; + } + + return containsAll(that); + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean isTransientSupported() { + return true; + } + + @Override + public io.usethesource.capsule.Set.Transient asTransient() { + return new TransientTrieSet_5Bits_Spec0To8_IntKey(this); + } + + /* + * For analysis purposes only. + */ + protected AbstractSetNode getRootNode() { + return rootNode; + } + + /* + * For analysis purposes only. + */ + protected Iterator nodeIterator() { + return new TrieSet_5Bits_Spec0To8_IntKeyNodeIterator(rootNode); + } + + /* + * For analysis purposes only. + */ + protected int getNodeCount() { + final Iterator it = nodeIterator(); + int sumNodes = 0; + + for (; it.hasNext(); it.next()) { + sumNodes += 1; + } + + return sumNodes; + } + + /* + * For analysis purposes only. Payload X Node + */ + protected int[][] arityCombinationsHistogram() { + final Iterator it = nodeIterator(); + final int[][] sumArityCombinations = new int[33][33]; + + while (it.hasNext()) { + final AbstractSetNode node = it.next(); + sumArityCombinations[node.payloadArity()][node.nodeArity()] += 1; + } + + return sumArityCombinations; + } + + /* + * For analysis purposes only. + */ + protected int[] arityHistogram() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = new int[33]; + + final int maxArity = 32; // TODO: factor out constant + + for (int j = 0; j <= maxArity; j++) { + for (int maxRestArity = maxArity - j, k = 0; k <= maxRestArity - j; k++) { + sumArity[j + k] += sumArityCombinations[j][k]; + } + } + + return sumArity; + } + + /* + * For analysis purposes only. + */ + public void printStatistics() { + final int[][] sumArityCombinations = arityCombinationsHistogram(); + final int[] sumArity = arityHistogram(); + final int sumNodes = getNodeCount(); + + final int[] cumsumArity = new int[33]; + for (int cumsum = 0, i = 0; i < 33; i++) { + cumsum += sumArity[i]; + cumsumArity[i] = cumsum; + } + + final float threshhold = 0.01f; // for printing results + for (int i = 0; i < 33; i++) { + float arityPercentage = (float) (sumArity[i]) / sumNodes; + float cumsumArityPercentage = (float) (cumsumArity[i]) / sumNodes; + + if (arityPercentage != 0 && arityPercentage >= threshhold) { + // details per level + StringBuilder bldr = new StringBuilder(); + int max = i; + for (int j = 0; j <= max; j++) { + for (int k = max - j; k <= max - j; k++) { + float arityCombinationsPercentage = (float) (sumArityCombinations[j][k]) / sumNodes; + + if (arityCombinationsPercentage != 0 && arityCombinationsPercentage >= threshhold) { + bldr.append(String.format("%d/%d: %s, ", j, k, + new DecimalFormat("0.00%").format(arityCombinationsPercentage))); + } + } + } + final String detailPercentages = bldr.toString(); + + // overview + System.out.println(String.format("%2d: %s\t[cumsum = %s]\t%s", i, + new DecimalFormat("0.00%").format(arityPercentage), + new DecimalFormat("0.00%").format(cumsumArityPercentage), detailPercentages)); + } + } + } + + abstract static class Optional { + + private static final Optional EMPTY = new Optional() { + @Override + boolean isPresent() { + return false; + } + + @Override + Object get() { + return null; + } + }; + + static Optional empty() { + return EMPTY; + } + + static Optional of(T value) { + return new Value(value); + } + + abstract boolean isPresent(); + + abstract T get(); + + private static final class Value extends Optional { + + private final T value; + + private Value(T value) { + this.value = value; + } + + @Override + boolean isPresent() { + return true; + } + + @Override + T get() { + return value; + } + } + } + + static final class SetResult { + + private int replacedValue; + private boolean isModified; + private boolean isReplaced; + + // update: inserted/removed single element, element count changed + public void modified() { + this.isModified = true; + } + + public void updated(int replacedValue) { + this.replacedValue = replacedValue; + this.isModified = true; + this.isReplaced = true; + } + + // update: neither element, nor element count changed + public static SetResult unchanged() { + return new SetResult(); + } + + private SetResult() { + } + + public boolean isModified() { + return isModified; + } + + public boolean hasReplacedValue() { + return isReplaced; + } + + public int getReplacedValue() { + return replacedValue; + } + } + + protected static interface INode { + + } + + protected static abstract class AbstractSetNode + implements INode { + + static final int TUPLE_LENGTH = 1; + + abstract boolean contains(final int key, final int keyHash, final int shift); + + abstract boolean contains(final int key, final int keyHash, final int shift, + final Comparator cmp); + + abstract Optional findByKey(final int key, final int keyHash, + final int shift); + + abstract Optional findByKey(final int key, final int keyHash, + final int shift, final Comparator cmp); + + abstract CompactSetNode updated(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final SetResult details); + + abstract CompactSetNode updated(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final SetResult details, final Comparator cmp); + + abstract CompactSetNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final SetResult details); + + abstract CompactSetNode removed(final AtomicReference mutator, final int key, + final int keyHash, final int shift, final SetResult details, final Comparator cmp); + + static final boolean isAllowedToEdit(AtomicReference x, AtomicReference y) { + return x != null && y != null && (x == y || x.get() == y.get()); + } + + abstract boolean hasNodes(); + + abstract int nodeArity(); + + abstract AbstractSetNode getNode(final int index); + + @Deprecated + Iterator nodeIterator() { + return new Iterator() { + + int nextIndex = 0; + final int nodeArity = AbstractSetNode.this.nodeArity(); + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + @Override + public AbstractSetNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return AbstractSetNode.this.getNode(nextIndex++); + } + + @Override + public boolean hasNext() { + return nextIndex < nodeArity; + } + }; + } + + abstract boolean hasPayload(); + + abstract int payloadArity(); + + abstract int getKey(final int index); + + @Deprecated + abstract boolean hasSlots(); + + abstract int slotArity(); + + abstract Object getSlot(final int index); + + /** + * The arity of this trie node (i.e. number of values and nodes stored on this level). + * + * @return sum of nodes and values stored within + */ + + int arity() { + return payloadArity() + nodeArity(); + } + + int size() { + final Iterator it = new SetKeyIterator(this); + + int size = 0; + while (it.hasNext()) { + size += 1; + it.next(); + } + + return size; + } + } + + protected static abstract class CompactSetNode extends AbstractSetNode { + + static final int HASH_CODE_LENGTH = 32; + + static final int BIT_PARTITION_SIZE = 5; + static final int BIT_PARTITION_MASK = 0b11111; + + static final int mask(final int keyHash, final int shift) { + return (keyHash >>> shift) & BIT_PARTITION_MASK; + } + + static final int bitpos(final int mask) { + return (int) (1 << mask); + } + + abstract int nodeMap(); + + abstract int dataMap(); + + static final byte SIZE_EMPTY = 0b00; + static final byte SIZE_ONE = 0b01; + static final byte SIZE_MORE_THAN_ONE = 0b10; + + /** + * Abstract predicate over a node's size. Value can be either {@value #SIZE_EMPTY}, + * {@value #SIZE_ONE}, or {@value #SIZE_MORE_THAN_ONE}. + * + * @return size predicate + */ + abstract byte sizePredicate(); + + @Override + abstract CompactSetNode getNode(final int index); + + boolean nodeInvariant() { + boolean inv1 = (size() - payloadArity() >= 2 * (arity() - payloadArity())); + boolean inv2 = (this.arity() == 0) ? sizePredicate() == SIZE_EMPTY : true; + boolean inv3 = + (this.arity() == 1 && payloadArity() == 1) ? sizePredicate() == SIZE_ONE : true; + boolean inv4 = (this.arity() >= 2) ? sizePredicate() == SIZE_MORE_THAN_ONE : true; + + boolean inv5 = (this.nodeArity() >= 0) && (this.payloadArity() >= 0) + && ((this.payloadArity() + this.nodeArity()) == this.arity()); + + return inv1 && inv2 && inv3 && inv4 && inv5; + } + + abstract CompactSetNode copyAndInsertValue(final AtomicReference mutator, + final int bitpos, final int key); + + abstract CompactSetNode copyAndRemoveValue(final AtomicReference mutator, + final int bitpos); + + abstract CompactSetNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactSetNode node); + + abstract CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node); + + abstract CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node); + + CompactSetNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + static final CompactSetNode mergeTwoKeyValPairs(final int key0, final int keyHash0, + final int key1, final int keyHash1, final int shift) { + assert !(key0 == key1); + + if (shift >= HASH_CODE_LENGTH) { + // throw new + // IllegalStateException("Hash collision not yet fixed."); + return new HashCollisionSetNode_5Bits_Spec0To8_IntKey(keyHash0, + (int[]) new int[]{key0, key1}); + } + + final int mask0 = mask(keyHash0, shift); + final int mask1 = mask(keyHash1, shift); + + if (mask0 != mask1) { + // both nodes fit on same level + final int dataMap = (int) (bitpos(mask0) | bitpos(mask1)); + + if (mask0 < mask1) { + return nodeOf(null, (int) 0, dataMap, key0, key1); + } else { + return nodeOf(null, (int) 0, dataMap, key1, key0); + } + } else { + final CompactSetNode node = + mergeTwoKeyValPairs(key0, keyHash0, key1, keyHash1, shift + BIT_PARTITION_SIZE); + // values fit on next level + + final int nodeMap = bitpos(mask0); + return nodeOf(null, nodeMap, (int) 0, node); + } + } + + static final CompactSetNode EMPTY_NODE; + + static { + + EMPTY_NODE = new Set0To0Node_5Bits_Spec0To8_IntKey(null, (int) 0, (int) 0); + + } + + ; + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + return new BitmapIndexedSetNode(mutator, nodeMap, dataMap, nodes); + } + + static final CompactSetNode nodeOf(AtomicReference mutator) { + return EMPTY_NODE; + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + return EMPTY_NODE; + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1) { + return new Set0To1Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2) { + return new Set0To2Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, node1, node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + return new Set0To3Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, node1, node2, node3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4) { + return new Set0To4Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, node1, node2, node3, + node4); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5) { + return new Set0To5Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6) { + return new Set0To6Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6, final CompactSetNode node7) { + return new Set0To7Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6, final CompactSetNode node7, final CompactSetNode node8) { + return new Set0To8Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, node1, node2, node3, + node4, node5, node6, node7, node8); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6, final CompactSetNode node7, final CompactSetNode node8, + final CompactSetNode node9) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{node9, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1) { + return new Set1To0Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1) { + return new Set1To1Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1, final CompactSetNode node2) { + return new Set1To2Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, node1, node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + return new Set1To3Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, node1, node2, + node3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4) { + return new Set1To4Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, node1, node2, + node3, node4); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5) { + return new Set1To5Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, node1, node2, + node3, node4, node5); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6) { + return new Set1To6Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, node1, node2, + node3, node4, node5, node6); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6, final CompactSetNode node7) { + return new Set1To7Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, node1, node2, + node3, node4, node5, node6, node7); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6, final CompactSetNode node7, final CompactSetNode node8) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, node8, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2) { + return new Set2To0Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final CompactSetNode node1) { + return new Set2To1Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final CompactSetNode node1, + final CompactSetNode node2) { + return new Set2To2Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, node1, + node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3) { + return new Set2To3Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, node1, + node2, node3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4) { + return new Set2To4Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, node1, + node2, node3, node4); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5) { + return new Set2To5Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, node1, + node2, node3, node4, node5); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5, final CompactSetNode node6) { + return new Set2To6Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, node1, + node2, node3, node4, node5, node6); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5, final CompactSetNode node6, final CompactSetNode node7) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, node7, node6, node5, node4, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3) { + return new Set3To0Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, + final CompactSetNode node1) { + return new Set3To1Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, + final CompactSetNode node1, final CompactSetNode node2) { + return new Set3To2Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + node1, node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3) { + return new Set3To3Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + node1, node2, node3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4) { + return new Set3To4Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + node1, node2, node3, node4); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4, final CompactSetNode node5) { + return new Set3To5Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + node1, node2, node3, node4, node5); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4, final CompactSetNode node5, final CompactSetNode node6) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, node6, node5, node4, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4) { + return new Set4To0Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final CompactSetNode node1) { + return new Set4To1Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final CompactSetNode node1, final CompactSetNode node2) { + return new Set4To2Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, node1, node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3) { + return new Set4To3Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, node1, node2, node3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4) { + return new Set4To4Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, node1, node2, node3, node4); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4, final CompactSetNode node5) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, key4, node5, node4, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5) { + return new Set5To0Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, key5); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final CompactSetNode node1) { + return new Set5To1Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, key5, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final CompactSetNode node1, final CompactSetNode node2) { + return new Set5To2Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, key5, node1, node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + return new Set5To3Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, key5, node1, node2, node3); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, key4, key5, node4, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6) { + return new Set6To0Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, key5, key6); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final CompactSetNode node1) { + return new Set6To1Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, key5, key6, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final CompactSetNode node1, final CompactSetNode node2) { + return new Set6To2Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, key5, key6, node1, node2); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, key4, key5, key6, node3, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final int key7) { + return new Set7To0Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, key5, key6, key7); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final int key7, final CompactSetNode node1) { + return new Set7To1Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, key5, key6, key7, node1); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final int key7, final CompactSetNode node1, + final CompactSetNode node2) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, key4, key5, key6, key7, node2, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final int key7, final int key8) { + return new Set8To0Node_5Bits_Spec0To8_IntKey(mutator, nodeMap, dataMap, key1, key2, key3, + key4, key5, key6, key7, key8); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final int key7, final int key8, + final CompactSetNode node1) { + // NOTE: reversed node argument list due to CHAMP encoding + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, key4, key5, key6, key7, key8, node1}); + } + + static final CompactSetNode nodeOf(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final int key7, final int key8, final int key9) { + return nodeOf(mutator, nodeMap, dataMap, + new Object[]{key1, key2, key3, key4, key5, key6, key7, key8, key9}); + } + + static final int index(final int bitmap, final int bitpos) { + return java.lang.Integer.bitCount(bitmap & (bitpos - 1)); + } + + static final int index(final int bitmap, final int mask, final int bitpos) { + return (bitmap == -1) ? mask : index(bitmap, bitpos); + } + + int dataIndex(final int bitpos) { + return java.lang.Integer.bitCount(dataMap() & (bitpos - 1)); + } + + int nodeIndex(final int bitpos) { + return java.lang.Integer.bitCount(nodeMap() & (bitpos - 1)); + } + + CompactSetNode nodeAt(final int bitpos) { + return getNode(nodeIndex(bitpos)); + } + + @Override + boolean contains(final int key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index) == key; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).contains(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return false; + } + + @Override + boolean contains(final int key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + final int dataMap = dataMap(); + if ((dataMap & bitpos) != 0) { + final int index = index(dataMap, mask, bitpos); + return getKey(index) == key; + } + + final int nodeMap = nodeMap(); + if ((nodeMap & bitpos) != 0) { + final int index = index(nodeMap, mask, bitpos); + return getNode(index).contains(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return false; + } + + @Override + Optional findByKey(final int key, final int keyHash, final int shift) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index) == key) { + return Optional.of(getKey(index)); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractSetNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE); + } + + return Optional.empty(); + } + + @Override + Optional findByKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int index = dataIndex(bitpos); + if (getKey(index) == key) { + return Optional.of(getKey(index)); + } + + return Optional.empty(); + } + + if ((nodeMap() & bitpos) != 0) { // node (not value) + final AbstractSetNode subNode = nodeAt(bitpos); + + return subNode.findByKey(key, keyHash, shift + BIT_PARTITION_SIZE, cmp); + } + + return Optional.empty(); + } + + @Override + CompactSetNode updated(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final SetResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + return this; + } else { + final CompactSetNode subNodeNew = mergeTwoKeyValPairs(currentKey, + transformHashCode(currentKey), key, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.updated(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key); + } + } + + @Override + CompactSetNode updated(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + final int currentKey = getKey(dataIndex); + + if (currentKey == key) { + return this; + } else { + final CompactSetNode subNodeNew = mergeTwoKeyValPairs(currentKey, + transformHashCode(currentKey), key, keyHash, shift + BIT_PARTITION_SIZE); + + details.modified(); + return copyAndMigrateFromInlineToNode(mutator, bitpos, subNodeNew); + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.updated(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (details.isModified()) { + return copyAndSetNode(mutator, bitpos, subNodeNew); + } else { + return this; + } + } else { + // no value + details.modified(); + return copyAndInsertValue(mutator, bitpos, key); + } + } + + @Override + CompactSetNode removed(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final SetResult details) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex) == key) { + details.modified(); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactSetNode.nodeOf(mutator, (int) 0, newDataMap, getKey(1)); + } else { + return CompactSetNode.nodeOf(mutator, (int) 0, newDataMap, getKey(0)); + } + } else if (this.arity() == 9) { + return removeInplaceValueAndConvertToSpecializedNode(mutator, bitpos); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + details.modified(); + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + @Override + CompactSetNode removed(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + final int mask = mask(keyHash, shift); + final int bitpos = bitpos(mask); + + if ((dataMap() & bitpos) != 0) { // inplace value + final int dataIndex = dataIndex(bitpos); + + if (getKey(dataIndex) == key) { + details.modified(); + + if (this.payloadArity() == 2 && this.nodeArity() == 0) { + /* + * Create new node with remaining pair. The new node will a) either become the new root + * returned, or b) unwrapped and inlined during returning. + */ + final int newDataMap = + (shift == 0) ? (int) (dataMap() ^ bitpos) : bitpos(mask(keyHash, 0)); + + if (dataIndex == 0) { + return CompactSetNode.nodeOf(mutator, (int) 0, newDataMap, getKey(1)); + } else { + return CompactSetNode.nodeOf(mutator, (int) 0, newDataMap, getKey(0)); + } + } else if (this.arity() == 9) { + return removeInplaceValueAndConvertToSpecializedNode(mutator, bitpos); + } else { + return copyAndRemoveValue(mutator, bitpos); + } + } else { + return this; + } + } else if ((nodeMap() & bitpos) != 0) { // node (not value) + final CompactSetNode subNode = nodeAt(bitpos); + final CompactSetNode subNodeNew = + subNode.removed(mutator, key, keyHash, shift + BIT_PARTITION_SIZE, details, cmp); + + if (!details.isModified()) { + return this; + } + + switch (subNodeNew.sizePredicate()) { + case 0: { + throw new IllegalStateException("Sub-node must have at least one element."); + } + case 1: { + // inline value (move to front) + details.modified(); + return copyAndMigrateFromNodeToInline(mutator, bitpos, subNodeNew); + } + default: { + // modify current node (set replacement node) + return copyAndSetNode(mutator, bitpos, subNodeNew); + } + } + } + + return this; + } + + /** + * @return 0 <= mask <= 2^BIT_PARTITION_SIZE - 1 + */ + static byte recoverMask(int map, byte i_th) { + assert 1 <= i_th && i_th <= 32; + + byte cnt1 = 0; + byte mask = 0; + + while (mask < 32) { + if ((map & 0x01) == 0x01) { + cnt1 += 1; + + if (cnt1 == i_th) { + return mask; + } + } + + map = (int) (map >> 1); + mask += 1; + } + + assert cnt1 != i_th; + throw new RuntimeException("Called with invalid arguments."); + } + + @Override + public String toString() { + final StringBuilder bldr = new StringBuilder(); + bldr.append('['); + + for (byte i = 0; i < payloadArity(); i++) { + final byte pos = recoverMask(dataMap(), (byte) (i + 1)); + bldr.append(String.format("@%d<#%d>", pos, Objects.hashCode(getKey(i)))); + + if (!((i + 1) == payloadArity())) { + bldr.append(", "); + } + } + + if (payloadArity() > 0 && nodeArity() > 0) { + bldr.append(", "); + } + + for (byte i = 0; i < nodeArity(); i++) { + final byte pos = recoverMask(nodeMap(), (byte) (i + 1)); + bldr.append(String.format("@%d: %s", pos, getNode(i))); + + if (!((i + 1) == nodeArity())) { + bldr.append(", "); + } + } + + bldr.append(']'); + return bldr.toString(); + } + + } + + protected static abstract class CompactMixedSetNode extends CompactSetNode { + + private final int nodeMap; + private final int dataMap; + + CompactMixedSetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + protected static abstract class CompactNodesOnlySetNode extends CompactSetNode { + + private final int nodeMap; + + CompactNodesOnlySetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.nodeMap = nodeMap; + } + + @Override + public int nodeMap() { + return nodeMap; + } + + @Override + public int dataMap() { + return 0; + } + + } + + protected static abstract class CompactValuesOnlySetNode extends CompactSetNode { + + private final int dataMap; + + CompactValuesOnlySetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + this.dataMap = dataMap; + } + + @Override + public int nodeMap() { + return 0; + } + + @Override + public int dataMap() { + return dataMap; + } + + } + + protected static abstract class CompactEmptySetNode extends CompactSetNode { + + CompactEmptySetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + } + + @Override + public int nodeMap() { + return 0; + } + + @Override + public int dataMap() { + return 0; + } + + } + + private static final class BitmapIndexedSetNode extends CompactMixedSetNode { + + final AtomicReference mutator; + final Object[] nodes; + + private BitmapIndexedSetNode(final AtomicReference mutator, final int nodeMap, + final int dataMap, final Object[] nodes) { + super(mutator, nodeMap, dataMap); + + this.mutator = mutator; + this.nodes = nodes; + + if (DEBUG) { + + assert (TUPLE_LENGTH * java.lang.Integer.bitCount(dataMap) + + java.lang.Integer.bitCount(nodeMap) == nodes.length); + + for (int i = 0; i < TUPLE_LENGTH * payloadArity(); i++) { + assert ((nodes[i] instanceof CompactSetNode) == false); + } + for (int i = TUPLE_LENGTH * payloadArity(); i < nodes.length; i++) { + assert ((nodes[i] instanceof CompactSetNode) == true); + } + } + + assert arity() > 8; + assert nodeInvariant(); + } + + @Override + int getKey(final int index) { + return (int) nodes[TUPLE_LENGTH * index]; + } + + @Override + CompactSetNode getNode(final int index) { + return (CompactSetNode) nodes[nodes.length - 1 - index]; + } + + @Override + boolean hasPayload() { + return dataMap() != 0; + } + + @Override + int payloadArity() { + return java.lang.Integer.bitCount(dataMap()); + } + + @Override + boolean hasNodes() { + return nodeMap() != 0; + } + + @Override + int nodeArity() { + return java.lang.Integer.bitCount(nodeMap()); + } + + @Override + Object getSlot(final int index) { + return nodes[index]; + } + + @Override + boolean hasSlots() { + return nodes.length != 0; + } + + @Override + int slotArity() { + return nodes.length; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + ((int) dataMap()); + result = prime * result + ((int) dataMap()); + result = prime * result + Arrays.hashCode(nodes); + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + BitmapIndexedSetNode that = (BitmapIndexedSetNode) other; + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + if (!Arrays.equals(nodes, that.nodes)) { + return false; + } + return true; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactSetNode node) { + + final int idx = this.nodes.length - 1 - nodeIndex(bitpos); + + if (isAllowedToEdit(this.mutator, mutator)) { + // no copying if already editable + this.nodes[idx] = node; + return this; + } else { + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length]; + + // copy 'src' and set 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, src.length); + dst[idx + 0] = node; + + return nodeOf(mutator, nodeMap(), dataMap(), dst); + } + } + + @Override + CompactSetNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length + 1]; + + // copy 'src' and insert 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + dst[idx + 0] = key; + System.arraycopy(src, idx, dst, idx + 1, src.length - idx); + + return nodeOf(mutator, nodeMap(), (int) (dataMap() | bitpos), dst); + } + + @Override + CompactSetNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + final int idx = TUPLE_LENGTH * dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = (Object[]) new Object[src.length - 1]; + + // copy 'src' and remove 1 element(s) at position 'idx' + System.arraycopy(src, 0, dst, 0, idx); + System.arraycopy(src, idx + 1, dst, idx, src.length - idx - 1); + + return nodeOf(mutator, nodeMap(), (int) (dataMap() ^ bitpos), dst); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + + final int idxOld = TUPLE_LENGTH * dataIndex(bitpos); + final int idxNew = this.nodes.length - TUPLE_LENGTH - nodeIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 1]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld <= idxNew; + System.arraycopy(src, 0, dst, 0, idxOld); + System.arraycopy(src, idxOld + 1, dst, idxOld, idxNew - idxOld); + dst[idxNew + 0] = node; + System.arraycopy(src, idxNew + 1, dst, idxNew + 1, src.length - idxNew - 1); + + return nodeOf(mutator, (int) (nodeMap() | bitpos), (int) (dataMap() ^ bitpos), dst); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + + final int idxOld = this.nodes.length - 1 - nodeIndex(bitpos); + final int idxNew = dataIndex(bitpos); + + final Object[] src = this.nodes; + final Object[] dst = new Object[src.length - 1 + 1]; + + // copy 'src' and remove 1 element(s) at position 'idxOld' and + // insert 1 element(s) at position 'idxNew' (TODO: carefully test) + assert idxOld >= idxNew; + System.arraycopy(src, 0, dst, 0, idxNew); + dst[idxNew + 0] = node.getKey(0); + System.arraycopy(src, idxNew, dst, idxNew + 1, idxOld - idxNew); + System.arraycopy(src, idxOld + 1, dst, idxOld + 1, src.length - idxOld - 1); + + return nodeOf(mutator, (int) (nodeMap() ^ bitpos), (int) (dataMap() | bitpos), dst); + } + + @Override + CompactSetNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (payloadArity()) { // 0 <= payloadArity <= 9 // or ts.nMax + case 1: { + + switch (valIndex) { + case 0: { + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + final CompactSetNode node3 = getNode(2); + final CompactSetNode node4 = getNode(3); + final CompactSetNode node5 = getNode(4); + final CompactSetNode node6 = getNode(5); + final CompactSetNode node7 = getNode(6); + final CompactSetNode node8 = getNode(7); + + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node7, + node8); + + } + case 2: { + int key1; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + break; + } + case 1: { + + key1 = getKey(0); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + final CompactSetNode node3 = getNode(2); + final CompactSetNode node4 = getNode(3); + final CompactSetNode node5 = getNode(4); + final CompactSetNode node6 = getNode(5); + final CompactSetNode node7 = getNode(6); + + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, node6, + node7); + + } + case 3: { + int key1; + int key2; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + final CompactSetNode node3 = getNode(2); + final CompactSetNode node4 = getNode(3); + final CompactSetNode node5 = getNode(4); + final CompactSetNode node6 = getNode(5); + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, node5, + node6); + + } + case 4: { + int key1; + int key2; + int key3; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + key3 = getKey(3); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + key3 = getKey(3); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(3); + + break; + } + case 3: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + final CompactSetNode node3 = getNode(2); + final CompactSetNode node4 = getNode(3); + final CompactSetNode node5 = getNode(4); + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node4, + node5); + + } + case 5: { + int key1; + int key2; + int key3; + int key4; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(3); + + key4 = getKey(4); + + break; + } + case 3: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(4); + + break; + } + case 4: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + final CompactSetNode node3 = getNode(2); + final CompactSetNode node4 = getNode(3); + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node3, + node4); + + } + case 6: { + int key1; + int key2; + int key3; + int key4; + int key5; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + break; + } + case 3: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(4); + + key5 = getKey(5); + + break; + } + case 4: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(5); + + break; + } + case 5: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + final CompactSetNode node3 = getNode(2); + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node2, + node3); + + } + case 7: { + int key1; + int key2; + int key3; + int key4; + int key5; + int key6; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + break; + } + case 3: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + break; + } + case 4: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(5); + + key6 = getKey(6); + + break; + } + case 5: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(6); + + break; + } + case 6: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(5); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + final CompactSetNode node2 = getNode(1); + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node1, + node2); + + } + case 8: { + int key1; + int key2; + int key3; + int key4; + int key5; + int key6; + int key7; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + break; + } + case 3: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + break; + } + case 4: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + break; + } + case 5: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(6); + + key7 = getKey(7); + + break; + } + case 6: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(5); + + key7 = getKey(7); + + break; + } + case 7: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(5); + + key7 = getKey(6); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + final CompactSetNode node1 = getNode(0); + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, node1); + + } + case 9: { + int key1; + int key2; + int key3; + int key4; + int key5; + int key6; + int key7; + int key8; + + switch (valIndex) { + case 0: { + + key1 = getKey(1); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 1: { + + key1 = getKey(0); + + key2 = getKey(2); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 2: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(3); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 3: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(4); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 4: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(5); + + key6 = getKey(6); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 5: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(6); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 6: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(5); + + key7 = getKey(7); + + key8 = getKey(8); + + break; + } + case 7: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(5); + + key7 = getKey(6); + + key8 = getKey(8); + + break; + } + case 8: { + + key1 = getKey(0); + + key2 = getKey(1); + + key3 = getKey(2); + + key4 = getKey(3); + + key5 = getKey(4); + + key6 = getKey(5); + + key7 = getKey(6); + + key8 = getKey(7); + + break; + } + default: + throw new IllegalStateException("Index out of range."); + } + + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, key8); + + } + default: + throw new IllegalStateException("Index out of range."); + } + } + } + + private static final class HashCollisionSetNode_5Bits_Spec0To8_IntKey extends CompactSetNode { + + private final int[] keys; + + private final int hash; + + HashCollisionSetNode_5Bits_Spec0To8_IntKey(final int hash, final int[] keys) { + this.keys = keys; + + this.hash = hash; + + assert payloadArity() >= 2; + } + + @Override + boolean contains(final int key, final int keyHash, final int shift) { + if (this.hash == keyHash) { + for (int k : keys) { + if (k == key) { + return true; + } + } + } + return false; + } + + @Override + boolean contains(final int key, final int keyHash, final int shift, + final Comparator cmp) { + if (this.hash == keyHash) { + for (int k : keys) { + if (k == key) { + return true; + } + } + } + return false; + } + + @Override + Optional findByKey(final int key, final int keyHash, final int shift) { + for (int i = 0; i < keys.length; i++) { + final int _key = keys[i]; + if (key == _key) { + return Optional.of(_key); + } + } + return Optional.empty(); + } + + @Override + Optional findByKey(final int key, final int keyHash, final int shift, + final Comparator cmp) { + for (int i = 0; i < keys.length; i++) { + final int _key = keys[i]; + if (key == _key) { + return Optional.of(_key); + } + } + return Optional.empty(); + } + + @Override + CompactSetNode updated(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final SetResult details) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx] == key) { + return this; + } + } + + final int[] keysNew = new int[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + details.modified(); + return new HashCollisionSetNode_5Bits_Spec0To8_IntKey(keyHash, keysNew); + } + + @Override + CompactSetNode updated(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + assert this.hash == keyHash; + + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx] == key) { + return this; + } + } + + final int[] keysNew = new int[this.keys.length + 1]; + + // copy 'this.keys' and insert 1 element(s) at position + // 'keys.length' + System.arraycopy(this.keys, 0, keysNew, 0, keys.length); + keysNew[keys.length + 0] = key; + System.arraycopy(this.keys, keys.length, keysNew, keys.length + 1, + this.keys.length - keys.length); + + details.modified(); + return new HashCollisionSetNode_5Bits_Spec0To8_IntKey(keyHash, keysNew); + } + + @Override + CompactSetNode removed(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final SetResult details) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx] == key) { + details.modified(); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final int theOtherKey = (idx == 0) ? keys[1] : keys[0]; + + return CompactSetNode.nodeOf(mutator).updated(mutator, theOtherKey, keyHash, 0, + details); + } else { + final int[] keysNew = new int[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + return new HashCollisionSetNode_5Bits_Spec0To8_IntKey(keyHash, keysNew); + } + } + } + return this; + } + + @Override + CompactSetNode removed(final AtomicReference mutator, final int key, final int keyHash, + final int shift, final SetResult details, final Comparator cmp) { + for (int idx = 0; idx < keys.length; idx++) { + if (keys[idx] == key) { + details.modified(); + + if (this.arity() == 1) { + return nodeOf(mutator); + } else if (this.arity() == 2) { + /* + * Create root node with singleton element. This node will be a) either be the new root + * returned, or b) unwrapped and inlined. + */ + final int theOtherKey = (idx == 0) ? keys[1] : keys[0]; + + return CompactSetNode.nodeOf(mutator).updated(mutator, theOtherKey, keyHash, 0, details, + cmp); + } else { + final int[] keysNew = new int[this.keys.length - 1]; + + // copy 'this.keys' and remove 1 element(s) at position + // 'idx' + System.arraycopy(this.keys, 0, keysNew, 0, idx); + System.arraycopy(this.keys, idx + 1, keysNew, idx, this.keys.length - idx - 1); + + return new HashCollisionSetNode_5Bits_Spec0To8_IntKey(keyHash, keysNew); + } + } + } + return this; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return keys.length; + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + int arity() { + return payloadArity(); + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + int getKey(final int index) { + return keys[index]; + } + + @Override + public CompactSetNode getNode(int index) { + throw new IllegalStateException("Is leaf node."); + } + + @Override + Object getSlot(final int index) { + throw new UnsupportedOperationException(); + } + + @Override + boolean hasSlots() { + throw new UnsupportedOperationException(); + } + + @Override + int slotArity() { + throw new UnsupportedOperationException(); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 0; + result = prime * result + hash; + result = prime * result + Arrays.hashCode(keys); + return result; + } + + @Override + public boolean equals(Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + HashCollisionSetNode_5Bits_Spec0To8_IntKey that = + (HashCollisionSetNode_5Bits_Spec0To8_IntKey) other; + + if (hash != that.hash) { + return false; + } + + if (arity() != that.arity()) { + return false; + } + + /* + * Linear scan for each key, because of arbitrary element order. + */ + outerLoop: + for (int i = 0; i < that.payloadArity(); i++) { + final int otherKey = that.getKey(i); + + for (int j = 0; j < keys.length; j++) { + final int key = keys[j]; + + if (key == otherKey) { + continue outerLoop; + } + } + return false; + + } + + return true; + } + + @Override + CompactSetNode copyAndInsertValue(final AtomicReference mutator, final int bitpos, + final int key) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndRemoveValue(final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndSetNode(final AtomicReference mutator, final int bitpos, + final CompactSetNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new UnsupportedOperationException(); + } + + @Override + CompactSetNode removeInplaceValueAndConvertToSpecializedNode( + final AtomicReference mutator, final int bitpos) { + throw new UnsupportedOperationException(); + } + + @Override + int nodeMap() { + throw new UnsupportedOperationException(); + } + + @Override + int dataMap() { + throw new UnsupportedOperationException(); + } + + } + + /** + * Iterator skeleton that uses a fixed stack in depth. + */ + private static abstract class AbstractSetIterator { + + private static final int MAX_DEPTH = 7; + + protected int currentValueCursor; + protected int currentValueLength; + protected AbstractSetNode currentValueNode; + + private int currentStackLevel = -1; + private final int[] nodeCursorsAndLengths = new int[MAX_DEPTH * 2]; + + AbstractSetNode[] nodes = new AbstractSetNode[MAX_DEPTH]; + + AbstractSetIterator(AbstractSetNode rootNode) { + if (rootNode.hasNodes()) { + currentStackLevel = 0; + + nodes[0] = rootNode; + nodeCursorsAndLengths[0] = 0; + nodeCursorsAndLengths[1] = rootNode.nodeArity(); + } + + if (rootNode.hasPayload()) { + currentValueNode = rootNode; + currentValueCursor = 0; + currentValueLength = rootNode.payloadArity(); + } + } + + /* + * search for next node that contains values + */ + private boolean searchNextValueNode() { + while (currentStackLevel >= 0) { + final int currentCursorIndex = currentStackLevel * 2; + final int currentLengthIndex = currentCursorIndex + 1; + + final int nodeCursor = nodeCursorsAndLengths[currentCursorIndex]; + final int nodeLength = nodeCursorsAndLengths[currentLengthIndex]; + + if (nodeCursor < nodeLength) { + final AbstractSetNode nextNode = nodes[currentStackLevel].getNode(nodeCursor); + nodeCursorsAndLengths[currentCursorIndex]++; + + if (nextNode.hasNodes()) { + /* + * put node on next stack level for depth-first traversal + */ + final int nextStackLevel = ++currentStackLevel; + final int nextCursorIndex = nextStackLevel * 2; + final int nextLengthIndex = nextCursorIndex + 1; + + nodes[nextStackLevel] = nextNode; + nodeCursorsAndLengths[nextCursorIndex] = 0; + nodeCursorsAndLengths[nextLengthIndex] = nextNode.nodeArity(); + } + + if (nextNode.hasPayload()) { + /* + * found next node that contains values + */ + currentValueNode = nextNode; + currentValueCursor = 0; + currentValueLength = nextNode.payloadArity(); + return true; + } + } else { + currentStackLevel--; + } + } + + return false; + } + + public boolean hasNext() { + if (currentValueCursor < currentValueLength) { + return true; + } else { + return searchNextValueNode(); + } + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } + + protected static class SetKeyIterator extends AbstractSetIterator + implements Iterator { + + SetKeyIterator(AbstractSetNode rootNode) { + super(rootNode); + } + + @Override + public java.lang.Integer next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } else { + return currentValueNode.getKey(currentValueCursor++); + } + } + + } + + /** + * Iterator that first iterates over inlined-values and then continues depth first recursively. + */ + private static class TrieSet_5Bits_Spec0To8_IntKeyNodeIterator + implements Iterator { + + final Deque> nodeIteratorStack; + + TrieSet_5Bits_Spec0To8_IntKeyNodeIterator(AbstractSetNode rootNode) { + nodeIteratorStack = new ArrayDeque<>(); + nodeIteratorStack.push(Collections.singleton(rootNode).iterator()); + } + + @Override + public boolean hasNext() { + while (true) { + if (nodeIteratorStack.isEmpty()) { + return false; + } else { + if (nodeIteratorStack.peek().hasNext()) { + return true; + } else { + nodeIteratorStack.pop(); + continue; + } + } + } + } + + @Override + public AbstractSetNode next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + AbstractSetNode innerNode = nodeIteratorStack.peek().next(); + + if (innerNode.hasNodes()) { + nodeIteratorStack.push(innerNode.nodeIterator()); + } + + return innerNode; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } + + static final class TransientTrieSet_5Bits_Spec0To8_IntKey + implements io.usethesource.capsule.Set.Transient { + + final private AtomicReference mutator; + private AbstractSetNode rootNode; + private int hashCode; + private int cachedSize; + + TransientTrieSet_5Bits_Spec0To8_IntKey( + TrieSet_5Bits_Spec0To8_IntKey trieSet_5Bits_Spec0To8_IntKey) { + this.mutator = new AtomicReference(Thread.currentThread()); + this.rootNode = trieSet_5Bits_Spec0To8_IntKey.rootNode; + this.hashCode = trieSet_5Bits_Spec0To8_IntKey.hashCode; + this.cachedSize = trieSet_5Bits_Spec0To8_IntKey.cachedSize; + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + } + + private boolean checkHashCodeAndSize(final int targetHash, final int targetSize) { + int hash = 0; + int size = 0; + + for (Iterator it = keyIterator(); it.hasNext(); ) { + final int key = it.next(); + + hash += (int) key; + size += 1; + } + + return hash == targetHash && size == targetSize; + } + + @Override + public boolean add(final java.lang.Integer key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean addAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean remove(final Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean removeAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean retainAll(final Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean contains(final Object o) { + try { + final int key = (int) o; + return rootNode.contains(key, transformHashCode(key), 0); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public boolean containsEquivalent(final Object o, final Comparator cmp) { + try { + final int key = (int) o; + return rootNode.contains(key, transformHashCode(key), 0, cmp); + } catch (ClassCastException unused) { + return false; + } + } + + @Override + public java.lang.Integer get(final Object o) { + try { + final int key = (int) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key), 0); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public java.lang.Integer getEquivalent(final Object o, final Comparator cmp) { + try { + final int key = (int) o; + final Optional result = + rootNode.findByKey(key, transformHashCode(key), 0, cmp); + + if (result.isPresent()) { + return result.get(); + } else { + return null; + } + } catch (ClassCastException unused) { + return null; + } + } + + @Override + public boolean __insert(final java.lang.Integer key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + + rootNode = newRootNode; + hashCode += keyHash; + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean __insertEquivalent(final java.lang.Integer key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.updated(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + + rootNode = newRootNode; + hashCode += keyHash; + cachedSize += 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return false; + } + + @Override + public boolean __insertAll(final Set set) { + boolean modified = false; + + for (final int key : set) { + modified |= this.__insert(key); + } + + return modified; + } + + @Override + public boolean __insertAllEquivalent(final Set set, + final Comparator cmp) { + boolean modified = false; + + for (final int key : set) { + modified |= this.__insertEquivalent(key, cmp); + } + + return modified; + } + + @Override + public boolean __remove(final java.lang.Integer key) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details); + + if (details.isModified()) { + rootNode = newRootNode; + hashCode = hashCode - keyHash; + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return false; + } + + @Override + public boolean __removeEquivalent(final java.lang.Integer key, final Comparator cmp) { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + final int keyHash = key.hashCode(); + final SetResult details = SetResult.unchanged(); + + final CompactSetNode newRootNode = + rootNode.removed(mutator, key, transformHashCode(keyHash), 0, details, cmp); + + if (details.isModified()) { + rootNode = newRootNode; + hashCode = hashCode - keyHash; + cachedSize = cachedSize - 1; + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + return true; + } + + if (DEBUG) { + assert checkHashCodeAndSize(hashCode, cachedSize); + } + + return false; + } + + @Override + public boolean __removeAll(final Set set) { + boolean modified = false; + + for (final int key : set) { + modified |= this.__remove(key); + } + + return modified; + } + + @Override + public boolean __removeAllEquivalent(final Set set, + final Comparator cmp) { + boolean modified = false; + + for (final int key : set) { + modified |= this.__removeEquivalent(key, cmp); + } + + return modified; + } + + @Override + public boolean __retainAll(final Set set) { + boolean modified = false; + + Iterator thisIterator = iterator(); + while (thisIterator.hasNext()) { + if (!set.contains(thisIterator.next())) { + thisIterator.remove(); + modified = true; + } + } + + return modified; + } + + @Override + public boolean __retainAllEquivalent( + final io.usethesource.capsule.Set.Transient transientSet, + final Comparator cmp) { + boolean modified = false; + + Iterator thisIterator = iterator(); + while (thisIterator.hasNext()) { + if (!transientSet.containsEquivalent(thisIterator.next(), cmp)) { + thisIterator.remove(); + modified = true; + } + } + + return modified; + } + + @Override + public boolean containsAll(Collection c) { + for (Object item : c) { + if (!contains(item)) { + return false; + } + } + return true; + } + + @Override + public boolean containsAllEquivalent(Collection c, Comparator cmp) { + for (Object item : c) { + if (!containsEquivalent(item, cmp)) { + return false; + } + } + return true; + } + + @Override + public int size() { + return cachedSize; + } + + @Override + public boolean isEmpty() { + return cachedSize == 0; + } + + @Override + public Iterator iterator() { + return keyIterator(); + } + + @Override + public Iterator keyIterator() { + return new TransientSetKeyIterator(this); + } + + public static class TransientSetKeyIterator extends SetKeyIterator { + + final TransientTrieSet_5Bits_Spec0To8_IntKey collection; + int lastKey; + + public TransientSetKeyIterator(final TransientTrieSet_5Bits_Spec0To8_IntKey collection) { + super(collection.rootNode); + this.collection = collection; + } + + @Override + public java.lang.Integer next() { + return lastKey = super.next(); + } + + @Override + public void remove() { + // TODO: test removal at iteration rigorously + collection.__remove(lastKey); + } + } + + @Override + public Object[] toArray() { + Object[] array = new Object[cachedSize]; + + int idx = 0; + for (java.lang.Integer key : this) { + array[idx++] = key; + } + + return array; + } + + @Override + public T[] toArray(final T[] a) { + List list = new ArrayList(cachedSize); + + for (java.lang.Integer key : this) { + list.add(key); + } + + return list.toArray(a); + } + + @Override + public boolean equals(final Object other) { + if (other == this) { + return true; + } + if (other == null) { + return false; + } + + if (other instanceof TransientTrieSet_5Bits_Spec0To8_IntKey) { + TransientTrieSet_5Bits_Spec0To8_IntKey that = + (TransientTrieSet_5Bits_Spec0To8_IntKey) other; + + if (this.cachedSize != that.cachedSize) { + return false; + } + + if (this.hashCode != that.hashCode) { + return false; + } + + return rootNode.equals(that.rootNode); + } else if (other instanceof Set) { + Set that = (Set) other; + + if (this.size() != that.size()) { + return false; + } + + return containsAll(that); + } + + return false; + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public io.usethesource.capsule.Set.Immutable freeze() { + if (mutator.get() == null) { + throw new IllegalStateException("Transient already frozen."); + } + + mutator.set(null); + return new TrieSet_5Bits_Spec0To8_IntKey(rootNode, hashCode, cachedSize); + } + } + + private static final class Set0To0Node_5Bits_Spec0To8_IntKey extends CompactEmptySetNode { + + Set0To0Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap) { + super(mutator, nodeMap, dataMap); + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return false; + } + + @Override + int slotArity() { + return 0; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_EMPTY; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + int result = 1; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + + return true; + } + + } + + private static final class Set0To1Node_5Bits_Spec0To8_IntKey extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + + Set0To1Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 1; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To1Node_5Bits_Spec0To8_IntKey that = (Set0To1Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set0To2Node_5Bits_Spec0To8_IntKey extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set0To2Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 2; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To2Node_5Bits_Spec0To8_IntKey that = (Set0To2Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set0To3Node_5Bits_Spec0To8_IntKey extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + + Set0To3Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 3; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To3Node_5Bits_Spec0To8_IntKey that = (Set0To3Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Set0To4Node_5Bits_Spec0To8_IntKey extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + + Set0To4Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To4Node_5Bits_Spec0To8_IntKey that = (Set0To4Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Set0To5Node_5Bits_Spec0To8_IntKey extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + + Set0To5Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To5Node_5Bits_Spec0To8_IntKey that = (Set0To5Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Set0To6Node_5Bits_Spec0To8_IntKey extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + private final CompactSetNode node6; + + Set0To6Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 6; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To6Node_5Bits_Spec0To8_IntKey that = (Set0To6Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + + return true; + } + + } + + private static final class Set0To7Node_5Bits_Spec0To8_IntKey extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + private final CompactSetNode node6; + private final CompactSetNode node7; + + Set0To7Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6, final CompactSetNode node7) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + case 6: + return node7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 7; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, node7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, node7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, node7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, node7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, node7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + result = prime * result + node7.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To7Node_5Bits_Spec0To8_IntKey that = (Set0To7Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + if (!(node7.equals(that.node7))) { + return false; + } + + return true; + } + + } + + private static final class Set0To8Node_5Bits_Spec0To8_IntKey extends CompactNodesOnlySetNode { + + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + private final CompactSetNode node6; + private final CompactSetNode node7; + private final CompactSetNode node8; + + Set0To8Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6, final CompactSetNode node7, final CompactSetNode node8) { + super(mutator, nodeMap, dataMap); + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + this.node8 = node8; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + case 6: + return node7; + case 7: + return node8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 8; + } + + @Override + boolean hasPayload() { + return false; + } + + @Override + int payloadArity() { + return 0; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node2, node3, node4, node5, node6, node7, + node8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node3, node4, node5, node6, node7, + node8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node4, node5, node6, node7, + node8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node5, node6, node7, + node8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node6, node7, + node8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, node7, + node8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node, + node8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node2, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node3, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node4, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node5, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node6, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, + node7, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, + node6, node8); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + result = prime * result + node7.hashCode(); + result = prime * result + node8.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set0To8Node_5Bits_Spec0To8_IntKey that = (Set0To8Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + if (!(node7.equals(that.node7))) { + return false; + } + if (!(node8.equals(that.node8))) { + return false; + } + + return true; + } + + } + + private static final class Set1To0Node_5Bits_Spec0To8_IntKey extends CompactValuesOnlySetNode { + + private final int key1; + + Set1To0Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 1; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To0Node_5Bits_Spec0To8_IntKey that = (Set1To0Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + + return true; + } + + } + + private static final class Set1To1Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final CompactSetNode node1; + + Set1To1Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 2; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To1Node_5Bits_Spec0To8_IntKey that = (Set1To1Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set1To2Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set1To2Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1, final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 3; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To2Node_5Bits_Spec0To8_IntKey that = (Set1To2Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set1To3Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + + Set1To3Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To3Node_5Bits_Spec0To8_IntKey that = (Set1To3Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Set1To4Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + + Set1To4Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To4Node_5Bits_Spec0To8_IntKey that = (Set1To4Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Set1To5Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + + Set1To5Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To5Node_5Bits_Spec0To8_IntKey that = (Set1To5Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Set1To6Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + private final CompactSetNode node6; + + Set1To6Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 6; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node2, node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node3, node4, node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node4, node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node, node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To6Node_5Bits_Spec0To8_IntKey that = (Set1To6Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + + return true; + } + + } + + private static final class Set1To7Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + private final CompactSetNode node6; + private final CompactSetNode node7; + + Set1To7Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3, final CompactSetNode node4, final CompactSetNode node5, + final CompactSetNode node6, final CompactSetNode node7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + this.node7 = node7; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + case 6: + return node7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 7; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 1; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, node5, + node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, node7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node3, node4, node5, node6, + node7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node4, node5, node6, + node7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node, node5, node6, + node7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node, node6, + node7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, node, + node7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, node6, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, node, node1, node2, node3, node4, node5, + node6, node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, node1, node, node2, node3, node4, node5, + node6, node7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node, node3, node4, node5, + node6, node7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node, node4, node5, + node6, node7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node, node5, + node6, node7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node, + node6, node7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node, node7); + case 7: + return nodeOf(mutator, nodeMap, dataMap, node1, node2, node3, node4, node5, node6, + node7, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node2, node3, node4, node5, node6, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node2, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node3, node4, node5, node6, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node3, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node4, node5, node6, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node4, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node5, node6, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node5, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, node6, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, node6, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, node5, + node7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, node5, + node7); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, node1, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, node1, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + result = prime * result + node7.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set1To7Node_5Bits_Spec0To8_IntKey that = (Set1To7Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + if (!(node7.equals(that.node7))) { + return false; + } + + return true; + } + + } + + private static final class Set2To0Node_5Bits_Spec0To8_IntKey extends CompactValuesOnlySetNode { + + private final int key1; + private final int key2; + + Set2To0Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 2; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To0Node_5Bits_Spec0To8_IntKey that = (Set2To0Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + + return true; + } + + } + + private static final class Set2To1Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final CompactSetNode node1; + + Set2To1Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 3; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To1Node_5Bits_Spec0To8_IntKey that = (Set2To1Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set2To2Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set2To2Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final CompactSetNode node1, + final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To2Node_5Bits_Spec0To8_IntKey that = (Set2To2Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set2To3Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + + Set2To3Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To3Node_5Bits_Spec0To8_IntKey that = (Set2To3Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Set2To4Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + + Set2To4Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node, node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To4Node_5Bits_Spec0To8_IntKey that = (Set2To4Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Set2To5Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + + Set2To5Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node, node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node, node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To5Node_5Bits_Spec0To8_IntKey that = (Set2To5Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Set2To6Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + private final CompactSetNode node6; + + Set2To6Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final CompactSetNode node1, + final CompactSetNode node2, final CompactSetNode node3, final CompactSetNode node4, + final CompactSetNode node5, final CompactSetNode node6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + this.node6 = node6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + case 5: + return node6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 6; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 2; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node4, + node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node4, + node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, node6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node3, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node, node4, node5, + node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node, node5, + node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, node, + node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, node5, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, node, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node, node2, node3, node4, + node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node, node3, node4, + node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node, node4, + node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node, + node5, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node5, + node, node6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key2, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, node, node1, node2, node3, node4, + node5, node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node, node2, node3, node4, + node5, node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node, node3, node4, + node5, node6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node, node4, + node5, node6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node, + node5, node6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, + node, node6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, node1, node2, node3, node4, node5, + node6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node2, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node2, node3, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node2, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node3, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node3, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node3, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node4, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node4, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node4, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node5, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node5, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node5, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node4, + node6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node4, + node6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node4, + node6); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, node1, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, node1, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + result = prime * result + node6.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set2To6Node_5Bits_Spec0To8_IntKey that = (Set2To6Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + if (!(node6.equals(that.node6))) { + return false; + } + + return true; + } + + } + + private static final class Set3To0Node_5Bits_Spec0To8_IntKey extends CompactValuesOnlySetNode { + + private final int key1; + private final int key2; + private final int key3; + + Set3To0Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 3; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set3To0Node_5Bits_Spec0To8_IntKey that = (Set3To0Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + + return true; + } + + } + + private static final class Set3To1Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final CompactSetNode node1; + + Set3To1Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, + final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set3To1Node_5Bits_Spec0To8_IntKey that = (Set3To1Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set3To2Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set3To2Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, + final CompactSetNode node1, final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set3To2Node_5Bits_Spec0To8_IntKey that = (Set3To2Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set3To3Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + + Set3To3Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set3To3Node_5Bits_Spec0To8_IntKey that = (Set3To3Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Set3To4Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + + Set3To4Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set3To4Node_5Bits_Spec0To8_IntKey that = (Set3To4Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Set3To5Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + private final CompactSetNode node5; + + Set3To5Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4, final CompactSetNode node5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + this.node5 = node5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + case 4: + return node5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 5; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 3; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node3, + node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node3, + node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node3, + node4, node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node3, + node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node4, node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node4, node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, node5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node, node1, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node, node4, + node5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, node, + node5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, node1, node2, node3, node4, + node5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node2, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node2, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node2, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node2, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node3, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node3, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node3, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node3, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node4, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node4, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node4, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node4, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node3, + node5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node3, + node5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node3, + node5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node3, + node5); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, node1, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, node1, node2, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + result = prime * result + node5.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set3To5Node_5Bits_Spec0To8_IntKey that = (Set3To5Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + if (!(node5.equals(that.node5))) { + return false; + } + + return true; + } + + } + + private static final class Set4To0Node_5Bits_Spec0To8_IntKey extends CompactValuesOnlySetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + + Set4To0Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 4; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set4To0Node_5Bits_Spec0To8_IntKey that = (Set4To0Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + + return true; + } + + } + + private static final class Set4To1Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final CompactSetNode node1; + + Set4To1Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set4To1Node_5Bits_Spec0To8_IntKey that = (Set4To1Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set4To2Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set4To2Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final CompactSetNode node1, final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set4To2Node_5Bits_Spec0To8_IntKey that = (Set4To2Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set4To3Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + + Set4To3Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node2, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node2, + node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set4To3Node_5Bits_Spec0To8_IntKey that = (Set4To3Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Set4To4Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + private final CompactSetNode node4; + + Set4To4Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final CompactSetNode node1, final CompactSetNode node2, final CompactSetNode node3, + final CompactSetNode node4) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + this.node4 = node4; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + case 3: + return node4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 4; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 4; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node2, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node2, node3, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node3, node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node3, node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node3, node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node, node1, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, node1, node2, node3, node4, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node2, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node2, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node2, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node2, node3, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node2, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node3, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node3, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node3, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node3, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node3, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node2, + node4); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node2, + node4); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node2, + node4); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node2, + node4); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node2, + node4); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, node1, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, node1, node2, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, node1, node2, + node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + result = prime * result + node4.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set4To4Node_5Bits_Spec0To8_IntKey that = (Set4To4Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + if (!(node4.equals(that.node4))) { + return false; + } + + return true; + } + + } + + private static final class Set5To0Node_5Bits_Spec0To8_IntKey extends CompactValuesOnlySetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final int key5; + + Set5To0Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 5; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + result = prime * result + (int) key5; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set5To0Node_5Bits_Spec0To8_IntKey that = (Set5To0Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + + return true; + } + + } + + private static final class Set5To1Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final int key5; + private final CompactSetNode node1; + + Set5To1Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + result = prime * result + (int) key5; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set5To1Node_5Bits_Spec0To8_IntKey that = (Set5To1Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set5To2Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final int key5; + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set5To2Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final CompactSetNode node1, final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + result = prime * result + (int) key5; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set5To2Node_5Bits_Spec0To8_IntKey that = (Set5To2Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set5To3Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final int key5; + private final CompactSetNode node1; + private final CompactSetNode node2; + private final CompactSetNode node3; + + Set5To3Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final CompactSetNode node1, final CompactSetNode node2, + final CompactSetNode node3) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.node1 = node1; + this.node2 = node2; + this.node3 = node3; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + case 2: + return node3; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 3; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 5; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node1, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node1, node2, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node1, node2, + node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node1, node2, + node3); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node1, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node2, node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node2, node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node2, node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node2, node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node3); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node, node1, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, node1, node2, node3, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node2, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node2, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node2, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node2, + node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node2, + node3); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node2, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node1, + node3); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node1, + node3); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node1, + node3); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node1, + node3); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node1, + node3); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node1, + node3); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, node1, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, node1, + node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, node1, + node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, node1, + node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + result = prime * result + (int) key5; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + result = prime * result + node3.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set5To3Node_5Bits_Spec0To8_IntKey that = (Set5To3Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + if (!(node3.equals(that.node3))) { + return false; + } + + return true; + } + + } + + private static final class Set6To0Node_5Bits_Spec0To8_IntKey extends CompactValuesOnlySetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final int key5; + private final int key6; + + Set6To0Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.key6 = key6; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 6; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 6; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + result = prime * result + (int) key5; + result = prime * result + (int) key6; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set6To0Node_5Bits_Spec0To8_IntKey that = (Set6To0Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(key6 == that.key6)) { + return false; + } + + return true; + } + + } + + private static final class Set6To1Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final int key5; + private final int key6; + private final CompactSetNode node1; + + Set6To1Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.key6 = key6; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 6; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + result = prime * result + (int) key5; + result = prime * result + (int) key6; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set6To1Node_5Bits_Spec0To8_IntKey that = (Set6To1Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(key6 == that.key6)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set6To2Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final int key5; + private final int key6; + private final CompactSetNode node1; + private final CompactSetNode node2; + + Set6To2Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final CompactSetNode node1, final CompactSetNode node2) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.key6 = key6; + this.node1 = node1; + this.node2 = node2; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + case 1: + return node2; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 2; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 6; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, node1, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, node1, + node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, node1, + node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, node1, + node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, node1, + node2); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, node1, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node1, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node1, node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node1, node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node1, node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node1, node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node2); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node, node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node1, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node1, node, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node1, node, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node1, node, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node1, node, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node1, node, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node, node1, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, node1, node2, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, + node2); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, + node2); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, + node2); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, + node2); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, + node2); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, + node2); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, + node2); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, + node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, + node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, + node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, + node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, + node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + result = prime * result + (int) key5; + result = prime * result + (int) key6; + + result = prime * result + node1.hashCode(); + result = prime * result + node2.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set6To2Node_5Bits_Spec0To8_IntKey that = (Set6To2Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(key6 == that.key6)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + if (!(node2.equals(that.node2))) { + return false; + } + + return true; + } + + } + + private static final class Set7To0Node_5Bits_Spec0To8_IntKey extends CompactValuesOnlySetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final int key5; + private final int key6; + private final int key7; + + Set7To0Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final int key7) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.key6 = key6; + this.key7 = key7; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 7; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 7; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, key7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, key7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, key7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, key7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, key7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, key7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, key7); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + result = prime * result + (int) key5; + result = prime * result + (int) key6; + result = prime * result + (int) key7; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set7To0Node_5Bits_Spec0To8_IntKey that = (Set7To0Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(key6 == that.key6)) { + return false; + } + if (!(key7 == that.key7)) { + return false; + } + + return true; + } + + } + + private static final class Set7To1Node_5Bits_Spec0To8_IntKey extends CompactMixedSetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final int key5; + private final int key6; + private final int key7; + private final CompactSetNode node1; + + Set7To1Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final int key7, final CompactSetNode node1) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.key6 = key6; + this.key7 = key7; + this.node1 = node1; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + switch (index) { + case 0: + return node1; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return true; + } + + @Override + int nodeArity() { + return 1; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 7; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, key7, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, key7, + node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, key7, + node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, key7, + node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, key7, + node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, key7, + node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, key7, + node1); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, key, + node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7, node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7, node1); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7, node1); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7, node1); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7, node1); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7, node1); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node1); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + final int index = nodeIndex(bitpos); + + final int nodeMap = this.nodeMap(); + final int dataMap = this.dataMap(); + + switch (index) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, node); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node, + node1); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, node1, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() ^ bitpos); + final int dataMap = (int) (this.dataMap() | bitpos); + + final int key = node.getKey(0); + + switch (bitIndex) { + case 0: + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, + key7); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, + key7); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, + key7); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, + key7); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, + key7); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, + key7); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, + key7); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, + key); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + result = prime * result + (int) key5; + result = prime * result + (int) key6; + result = prime * result + (int) key7; + + result = prime * result + node1.hashCode(); + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set7To1Node_5Bits_Spec0To8_IntKey that = (Set7To1Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(key6 == that.key6)) { + return false; + } + if (!(key7 == that.key7)) { + return false; + } + if (!(node1.equals(that.node1))) { + return false; + } + + return true; + } + + } + + private static final class Set8To0Node_5Bits_Spec0To8_IntKey extends CompactValuesOnlySetNode { + + private final int key1; + private final int key2; + private final int key3; + private final int key4; + private final int key5; + private final int key6; + private final int key7; + private final int key8; + + Set8To0Node_5Bits_Spec0To8_IntKey(final AtomicReference mutator, final int nodeMap, + final int dataMap, final int key1, final int key2, final int key3, final int key4, + final int key5, final int key6, final int key7, final int key8) { + super(mutator, nodeMap, dataMap); + this.key1 = key1; + this.key2 = key2; + this.key3 = key3; + this.key4 = key4; + this.key5 = key5; + this.key6 = key6; + this.key7 = key7; + this.key8 = key8; + + assert nodeInvariant(); + } + + @Override + boolean hasSlots() { + return true; + } + + @Override + int slotArity() { + return 8; + } + + @Override + Object getSlot(final int index) { + final int boundary = payloadArity(); + + if (index < boundary) { + return getKey(index); + } else { + return getNode(index - boundary); + } + } + + @Override + CompactSetNode getNode(int index) { + throw new IllegalStateException("Index out of range."); + } + + @Override + int getKey(int index) { + switch (index) { + case 0: + return key1; + case 1: + return key2; + case 2: + return key3; + case 3: + return key4; + case 4: + return key5; + case 5: + return key6; + case 6: + return key7; + case 7: + return key8; + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + boolean hasNodes() { + return false; + } + + @Override + int nodeArity() { + return 0; + } + + @Override + boolean hasPayload() { + return true; + } + + @Override + int payloadArity() { + return 8; + } + + @Override + byte sizePredicate() { + return SIZE_MORE_THAN_ONE; + } + + @Override + CompactSetNode copyAndInsertValue(AtomicReference mutator, final int bitpos, + final int key) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() | bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key, key1, key2, key3, key4, key5, key6, key7, + key8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key, key2, key3, key4, key5, key6, key7, + key8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key, key3, key4, key5, key6, key7, + key8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key, key4, key5, key6, key7, + key8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key, key5, key6, key7, + key8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key, key6, key7, + key8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key, key7, + key8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, key, + key8); + case 8: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, key8, + key); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndRemoveValue(AtomicReference mutator, final int bitpos) { + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap()); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7, key8); + case 1: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7, key8); + case 2: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7, key8); + case 3: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7, key8); + case 4: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7, key8); + case 5: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7, key8); + case 6: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key8); + case 7: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7); + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndSetNode(AtomicReference mutator, final int bitpos, + CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + CompactSetNode copyAndMigrateFromInlineToNode(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + final int bitIndex = nodeIndex(bitpos); + final int valIndex = dataIndex(bitpos); + + final int nodeMap = (int) (this.nodeMap() | bitpos); + final int dataMap = (int) (this.dataMap() ^ bitpos); + + switch (valIndex) { + case 0: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key2, key3, key4, key5, key6, key7, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 1: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key3, key4, key5, key6, key7, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 2: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key4, key5, key6, key7, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 3: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key5, key6, key7, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 4: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key6, key7, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 5: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key7, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 6: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key8, + node); + default: + throw new IllegalStateException("Index out of range."); + } + case 7: + switch (bitIndex) { + case 0: + return nodeOf(mutator, nodeMap, dataMap, key1, key2, key3, key4, key5, key6, key7, + node); + default: + throw new IllegalStateException("Index out of range."); + } + default: + throw new IllegalStateException("Index out of range."); + } + } + + @Override + CompactSetNode copyAndMigrateFromNodeToInline(final AtomicReference mutator, + final int bitpos, final CompactSetNode node) { + throw new IllegalStateException("Index out of range."); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((int) nodeMap()); + result = prime * result + ((int) dataMap()); + + result = prime * result + (int) key1; + result = prime * result + (int) key2; + result = prime * result + (int) key3; + result = prime * result + (int) key4; + result = prime * result + (int) key5; + result = prime * result + (int) key6; + result = prime * result + (int) key7; + result = prime * result + (int) key8; + + return result; + } + + @Override + public boolean equals(final Object other) { + if (null == other) { + return false; + } + if (this == other) { + return true; + } + if (getClass() != other.getClass()) { + return false; + } + Set8To0Node_5Bits_Spec0To8_IntKey that = (Set8To0Node_5Bits_Spec0To8_IntKey) other; + + if (nodeMap() != that.nodeMap()) { + return false; + } + if (dataMap() != that.dataMap()) { + return false; + } + + if (!(key1 == that.key1)) { + return false; + } + if (!(key2 == that.key2)) { + return false; + } + if (!(key3 == that.key3)) { + return false; + } + if (!(key4 == that.key4)) { + return false; + } + if (!(key5 == that.key5)) { + return false; + } + if (!(key6 == that.key6)) { + return false; + } + if (!(key7 == that.key7)) { + return false; + } + if (!(key8 == that.key8)) { + return false; + } + + return true; + } + + } + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/util/DataLayoutHelper.java b/capsule-experimental/src/main/java/io/usethesource/capsule/util/DataLayoutHelper.java new file mode 100644 index 0000000..c69b7ec --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/util/DataLayoutHelper.java @@ -0,0 +1,175 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.util; + +import java.lang.reflect.Field; +import java.util.LinkedList; +import java.util.List; +import java.util.stream.Stream; + +public class DataLayoutHelper { + + public static final long[] arrayOffsets(final Class clazz, final String[] fieldNames) { + try { + long[] arrayOffsets = new long[fieldNames.length]; + + for (int i = 0; i < fieldNames.length; i++) { + arrayOffsets[i] = unsafe.objectFieldOffset(clazz.getDeclaredField(fieldNames[i])); + } + + return arrayOffsets; + } catch (NoSuchFieldException | SecurityException e) { + throw new RuntimeException(e); + } + } + + public static final long fieldOffset(final Class clazz, final String fieldName) { + try { + List bottomUpHierarchy = new LinkedList<>(); + + Class currentClass = clazz; + while (currentClass != null) { + bottomUpHierarchy.add(currentClass); + currentClass = currentClass.getSuperclass(); + } + + final java.util.Optional fieldNameField = bottomUpHierarchy.stream() + .flatMap(hierarchyClass -> Stream.of(hierarchyClass.getDeclaredFields())) + .filter(f -> f.getName().equals(fieldName)).findFirst(); + + if (fieldNameField.isPresent()) { + + if (java.lang.reflect.Modifier.isStatic(fieldNameField.get().getModifiers())) { + return unsafe.staticFieldOffset(fieldNameField.get()); + } else { + return unsafe.objectFieldOffset(fieldNameField.get()); + } + } else { + return sun.misc.Unsafe.INVALID_FIELD_OFFSET; + } + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + protected static final sun.misc.Unsafe initializeUnsafe() { + try { + Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe"); + field.setAccessible(true); + return (sun.misc.Unsafe) field.get(null); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + public static final sun.misc.Unsafe unsafe = initializeUnsafe(); + + static final long initializeArrayBase() { + try { + // assuems that both are of type Object and next to each other in memory + return DataLayoutHelperChild.arrayOffsets[0]; + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + public static final long arrayBase = initializeArrayBase(); + + static final long initializeAddressSize() { + try { + // assuems that both are of type Object and next to each other in memory + return DataLayoutHelperChild.arrayOffsets[1] - DataLayoutHelperChild.arrayOffsets[0]; + } catch (SecurityException e) { + throw new RuntimeException(e); + } + } + + public static final long addressSize = initializeAddressSize(); + + @SuppressWarnings("restriction") + static final boolean isCopyMemorySupported() { + DataLayoutHelperChild src = new DataLayoutHelperChild(new Object(), new Object()); + DataLayoutHelperChild dst = new DataLayoutHelperChild(); + + try { + unsafe.copyMemory(src, DataLayoutHelperChild.arrayOffsets[0], dst, + DataLayoutHelperChild.arrayOffsets[0], 2 * addressSize); + return src.slot0 == dst.slot0 && src.slot1 == dst.slot1; + } catch (IllegalArgumentException e) { + return false; + } + } + + abstract static class DataLayoutHelperBase { + + final int rawMap1; + final int rawMap2; + + public DataLayoutHelperBase(Object unused, final int rawMap1, final int rawMap2) { + this.rawMap1 = rawMap1; + this.rawMap2 = rawMap2; + } + + } + + static class DataLayoutHelperChild extends DataLayoutHelperBase { + + static final long[] arrayOffsets = + arrayOffsets(DataLayoutHelperChild.class, new String[] {"slot0", "slot1"}); + + static final int nodeArity = 0; + + static final int payloadArity = 0; + + static final int slotArity = 2; + + static final int untypedSlotArity = 2; + + static final long arrayOffsetLast = /* arrayBase + 1 * addressSize */ -1; + + public final Object slot0; + + public final Object slot1; + + DataLayoutHelperChild() { + super(null, (byte) 0, (byte) 0); + this.slot0 = null; + this.slot1 = null; + } + + DataLayoutHelperChild(final Object slot0, final Object slot1) { + super(null, (byte) 0, (byte) 0); + this.slot0 = slot0; + this.slot1 = slot1; + } + + } + + // static final long globalRawMap1Offset = fieldOffset(DataLayoutHelperChild.class, "rawMap1"); + // + // static final long globalRawMap2Offset = fieldOffset(DataLayoutHelperChild.class, "rawMap2"); + // + // static final long globalArrayOffsetsOffset = + // fieldOffset(DataLayoutHelperChild.class, "arrayOffsets"); + // + // static final long globalNodeArityOffset = + // fieldOffset(DataLayoutHelperChild.class, "nodeArity"); + // + // static long globalPayloadArityOffset = + // fieldOffset(DataLayoutHelperChild.class, "payloadArity"); + // + // static final long globalSlotArityOffset = + // fieldOffset(DataLayoutHelperChild.class, "slotArity"); + // + // static long globalUntypedSlotArityOffset = + // fieldOffset(DataLayoutHelperChild.class, "untypedSlotArity"); + // + // static long globalArrayOffsetLastOffset = + // fieldOffset(DataLayoutHelperChild.class, "arrayOffsetLast"); + +} diff --git a/capsule-experimental/src/main/java/io/usethesource/capsule/util/RangecopyUtils.java b/capsule-experimental/src/main/java/io/usethesource/capsule/util/RangecopyUtils.java new file mode 100644 index 0000000..6f014ad --- /dev/null +++ b/capsule-experimental/src/main/java/io/usethesource/capsule/util/RangecopyUtils.java @@ -0,0 +1,940 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.util; + +import static io.usethesource.capsule.util.DataLayoutHelper.addressSize; +import static io.usethesource.capsule.util.DataLayoutHelper.isCopyMemorySupported; +import static io.usethesource.capsule.util.DataLayoutHelper.unsafe; + +public final class RangecopyUtils { + + public static final T allocateHeapRegion(final Class clazz) { + try { + final Object newInstance = unsafe.allocateInstance(clazz); + return (T) newInstance; + } catch (ClassCastException | InstantiationException e) { + throw new RuntimeException(e); + } + } + + public static final T allocateHeapRegion(final Class[][] lookupTable, + final int dim1, final int dim2) { + final Class clazz = lookupTable[dim1][dim2]; + return allocateHeapRegion(clazz); + } + + public static final boolean _do_rangecompareObjectRegion(Object src, Object dst, long offset, + int length) { + long strideSizeInBytes = addressSize; + + for (int i = 0; i < length; i++) { + Object srcObject = unsafe.getObject(src, offset); + Object dstObject = unsafe.getObject(dst, offset); + offset += strideSizeInBytes; + + // assumes that both srcObject != null + if (!((srcObject == dstObject) || (srcObject.equals(dstObject)))) { + return false; + } + } + + return true; + } + + /* + * final Object[] src = this.nodes; final Object[] dst = (Object[]) new Object[src.length]; + * + * // copy 'src' and set 1 element(s) at position 'idx' System.arraycopy(src, 0, dst, 0, + * src.length); dst[idx + 0] = node; + * + * rangecopyObjectRegion(src, rareBase, 0, dst, rareBase, 0, untypedSlotArity); + * setInObjectRegion(src, rareBase, idx, node); + * + * rangecopyObjectRegion(src, rareBase, dst, rareBase, nodeBase - rareBase); + * setInObjectRegion(src, rareBase + idx * addressSize, node); + */ + + @Deprecated + public final static void __setInIntRegion(Object dst, long dstRegionOffset, int dstPos, + int value) { + unsafe.putInt(dst, dstRegionOffset + dstPos * addressSize, value); + } + + public final static long setInIntRegionVarArgs(Object dst, long dstOffset, int value0, + int value1) { + long strideSizeInBytes = 4; + + unsafe.putInt(dst, dstOffset, value0); + unsafe.putInt(dst, dstOffset + strideSizeInBytes, value1); + + return 2 * strideSizeInBytes; + } + + @Deprecated + public final static long setInObjectRegionVarArgs(Object dst, long dstRegionOffset, int dstPos, + Object value0, Object value1) { + long dstOffset = dstRegionOffset + dstPos * addressSize; + return setInObjectRegionVarArgs(dst, dstOffset, value0, value1); + } + + public final static long setInObjectRegionVarArgs(Object dst, long dstOffset, Object value0) { + unsafe.putObject(dst, dstOffset, value0); + return addressSize; + } + + public final static long setInObjectRegionVarArgs(Object dst, long dstOffset, Object value0, + Object value1) { + // System.out.println(org.openjdk.jol.util.VMSupport.vmDetails()); + // System.out.println(org.openjdk.jol.info.ClassLayout.parseClass(dst.getClass()).toPrintable()); + + long strideSizeInBytes = addressSize; + + unsafe.putObject(dst, dstOffset, value0); + unsafe.putObject(dst, dstOffset + strideSizeInBytes, value1); + + return 2 * strideSizeInBytes; + } + + public final static long setInObjectRegionVarArgs(Object dst, long dstRegionOffset, int dstPos, + Object... values) { + long dstOffset = dstRegionOffset + dstPos * addressSize; + return setInObjectRegionVarArgs(dst, dstOffset, values); + } + + public final static long setInObjectRegionVarArgs(Object dst, long dstOffset, Object... values) { + long offset = dstOffset; + + for (Object value : values) { + unsafe.putObject(dst, offset, value); + offset += addressSize; + } + + return offset - dstOffset; // bytes copied + } + + public final static void setInIntRegion(Object dst, long dstRegionOffset, int dstPos, int value) { + unsafe.putObject(dst, dstRegionOffset + dstPos * 4, value); + } + + public final static void setInObjectRegion(Object dst, long dstRegionOffset, int dstPos, + Object value) { + unsafe.putObject(dst, dstRegionOffset + dstPos * addressSize, value); + } + + public final static Object getFromObjectRegion(Object dst, long dstOffset) { + return unsafe.getObject(dst, dstOffset); + } + + public final static T getFromObjectRegionAndCast(Object dst, long dstOffset) { + return (T) unsafe.getObject(dst, dstOffset); + } + + public final static Object getFromObjectRegion(Object dst, long dstRegionOffset, int dstPos) { + return unsafe.getObject(dst, dstRegionOffset + dstPos * addressSize); + } + + public final static T getFromObjectRegionAndCast(Object dst, long dstRegionOffset, + int dstPos) { + return (T) unsafe.getObject(dst, dstRegionOffset + dstPos * addressSize); + } + + public final static T uncheckedCast(Object o) { + return (T) o; + } + + public static final boolean USE_NEXT_CLASS_ARRAY = false; + + private static final boolean IS_COPY_MEMORY_SUPPORTED; + + private static final boolean USE_COPY_MEMORY; + + static { + IS_COPY_MEMORY_SUPPORTED = isCopyMemorySupported(); + +// if (IS_COPY_MEMORY_SUPPORTED) { +// System.err.println(String.format("%s.%s=%s", RangecopyUtils.class.getName(), +// "isSunMiscUnsafeCopyMemorySupported", "true")); +// } else { +// System.err.println(String.format("%s.%s=%s", RangecopyUtils.class.getName(), +// "isSunMiscUnsafeCopyMemorySupported", "false")); +// } + + USE_COPY_MEMORY = IS_COPY_MEMORY_SUPPORTED && !Boolean.getBoolean( + String.format("%s.%s", RangecopyUtils.class.getName(), "dontUseSunMiscUnsafeCopyMemory")); + +// if (USE_COPY_MEMORY) { +// System.err.println(String.format("%s.%s=%s", RangecopyUtils.class.getName(), +// "useSunMiscUnsafeCopyMemory", "true")); +// } else { +// System.err.println(String.format("%s.%s=%s", RangecopyUtils.class.getName(), +// "useSunMiscUnsafeCopyMemory", "false")); +// } + } + + public static final long rangecopyPrimitiveRegion(Object src, long srcOffset, Object dst, + long dstOffset, long sizeInBytes) { + if (sizeInBytes != 0) { + if (USE_COPY_MEMORY) { + unsafe.copyMemory(src, srcOffset, dst, dstOffset, sizeInBytes); + } else { + final int size = 4; + final int length = (int) (sizeInBytes / size); + + for (int i = 0; i < length; i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + } + } + + return sizeInBytes; + } + + // public static final long rangecopyObjectRegion(Object src, long srcOffset, Object dst, long + // dstOffset, + // int length) { + //// if (length == 0) { + //// return 0; + //// } + // + // if (USE_COPY_MEMORY) { + // long sizeInBytes = length * addressSize; + // if (sizeInBytes != 0) + // unsafe.copyMemory(src, srcOffset, dst, dstOffset, sizeInBytes); + // return sizeInBytes; + // } else { + // long strideSizeInBytes = addressSize; + // long sizeInBytes = length * strideSizeInBytes; + // + // for (int i = 0; i < length; i++) { + // unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + // srcOffset += strideSizeInBytes; + // dstOffset += strideSizeInBytes; + // } + // + // return sizeInBytes; + // } + // } + + public static final long rangecopyObjectRegion(Object src, long srcRegionOffset, int srcPos, + Object dst, long dstRegionOffset, int dstPos, int length) { + if (length == 0) { + return 0L; + } + + long strideSizeInBytes = addressSize; + return _do_rangecopyObjectRegion(src, srcRegionOffset + srcPos * strideSizeInBytes, dst, + dstRegionOffset + dstPos * strideSizeInBytes, length); + } + + public static final long rangecopyObjectRegion(Object src, Object dst, long offset, int length) { + if (length == 0) { + return 0L; + } + + return _do_rangecopyObjectRegion(src, dst, offset, length); + + // _do_rangecopyObjectRegion(src, srcOffset, dst, dstOffset, length); + // return length * addressSize; + } + + public static final long rangecopyObjectRegion(Object src, long srcOffset, Object dst, + long dstOffset, int length) { + if (length == 0) { + return 0L; + } + + return _do_rangecopyObjectRegion(src, srcOffset, dst, dstOffset, length); + + // _do_rangecopyObjectRegion(src, srcOffset, dst, dstOffset, length); + // return length * addressSize; + } + + public static final long _do_rangecopyObjectRegion(Object src, Object dst, long offset, + int length) { + if (USE_COPY_MEMORY) { + long strideSizeInBytes = addressSize; + long sizeInBytes = length * strideSizeInBytes; + unsafe.copyMemory(src, offset, dst, offset, sizeInBytes); + return sizeInBytes; + } else { + long strideSizeInBytes = addressSize; + long sizeInBytes = length * strideSizeInBytes; + for (int i = 0; i < length; i++) { + unsafe.putObject(dst, offset, unsafe.getObject(src, offset)); + offset += strideSizeInBytes; + } + return sizeInBytes; + } + + // return sizeInBytes; + } + + public static final long _do_rangecopyObjectRegion(Object src, long srcOffset, Object dst, + long dstOffset, int length) { + if (USE_COPY_MEMORY) { + long strideSizeInBytes = addressSize; + long sizeInBytes = length * strideSizeInBytes; + unsafe.copyMemory(src, srcOffset, dst, dstOffset, sizeInBytes); + return sizeInBytes; + } else { + long strideSizeInBytes = addressSize; + long sizeInBytes = length * strideSizeInBytes; + for (int i = 0; i < length; i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += strideSizeInBytes; + dstOffset += strideSizeInBytes; + } + return sizeInBytes; + } + + // return sizeInBytes; + } + + // public static final long rangecopyIntRegion(Object src, long srcOffset, Object dst, long + // dstOffset, + // int length) { + //// if (length == 0) { + //// return 0; + //// } + // + // if (USE_COPY_MEMORY) { + // long sizeInBytes = length * 4L; + // if (sizeInBytes != 0) + // unsafe.copyMemory(src, srcOffset, dst, dstOffset, sizeInBytes); + // return sizeInBytes; + // } else { + // long strideSizeInBytes = 4; + // long offset = srcOffset; + // + // for (int i = 0; i < length; i++) { + // unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + // srcOffset += strideSizeInBytes; + // dstOffset += strideSizeInBytes; + // } + // + // return offset - srcOffset; + // } + // } + + public static final long rangecopyIntRegion(Object src, long srcRegionOffset, int srcPos, + Object dst, long dstRegionOffset, int dstPos, int length) { + if (length == 0) { + return 0L; + } + + long strideSizeInBytes = 4L; + return _do_rangecopyIntRegion(src, srcRegionOffset + srcPos * strideSizeInBytes, dst, + dstRegionOffset + dstPos * strideSizeInBytes, length); + } + + public static final long rangecopyIntRegion(Object src, long srcOffset, Object dst, + long dstOffset, int length) { + if (length == 0) { + return 0L; + } + + // return _do_rangecopyIntRegion(src, srcOffset, dst, dstOffset, length); + + _do_rangecopyIntRegion(src, srcOffset, dst, dstOffset, length); + return length * 4L; + } + + public static final long _do_rangecopyIntRegion(Object src, long srcOffset, Object dst, + long dstOffset, int length) { + long strideSizeInBytes = 4L; + long sizeInBytes = length * strideSizeInBytes; + + if (USE_COPY_MEMORY) { + unsafe.copyMemory(src, srcOffset, dst, dstOffset, sizeInBytes); + } else { + for (int i = 0; i < length; i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += strideSizeInBytes; + dstOffset += strideSizeInBytes; + } + } + + return sizeInBytes; + } + + public static final long __rangecopyObjectRegion(Object src, long srcOffset, Object dst, + long dstOffset, long sizeInBytes) { + if (sizeInBytes != 0) { + if (USE_COPY_MEMORY) { + unsafe.copyMemory(src, srcOffset, dst, dstOffset, sizeInBytes); + } else { + final int length = (int) (sizeInBytes / addressSize); + + for (int i = 0; i < length; i++) { + unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + srcOffset += addressSize; + dstOffset += addressSize; + } + } + } + return sizeInBytes; + } + + public static final void __rangecopyObjectRegion(Object src, Object dst, long offset, + long sizeInBytes) { + if (USE_COPY_MEMORY) { + unsafe.copyMemory(src, offset, dst, offset, sizeInBytes); + } else { + // final int length = (int) (sizeInBytes / addressSize); + // + // for (int i = 0; i < length; i++) { + // unsafe.putObject(dst, offset, unsafe.getObject(src, offset)); + // offset += addressSize; + // } + } + } + + @Deprecated + public static final void __rangecopyIntRegion(Object src, long srcRegionOffset, int srcPos, + Object dst, long dstRegionOffset, int dstPos, int length) { + if (length != 0) { + int strideSizeInBytes = 4; + + if (USE_COPY_MEMORY) { + long sizeInBytes = length * strideSizeInBytes; + unsafe.copyMemory(src, srcRegionOffset + srcPos * strideSizeInBytes, dst, + dstRegionOffset + dstPos * strideSizeInBytes, sizeInBytes); + } else { + long srcOffset = srcRegionOffset + srcPos * strideSizeInBytes; + long dstOffset = dstRegionOffset + dstPos * strideSizeInBytes; + + for (int i = 0; i < length; i++) { + unsafe.putInt(dst, dstOffset, unsafe.getInt(src, srcOffset)); + srcOffset += strideSizeInBytes; + dstOffset += strideSizeInBytes; + } + } + } + } + + public static final long sizeOfObject() { + return addressSize; + } + + // public static final void rangecopyObjectRegion(Object src, long srcRegionOffset, int srcPos, + // Object dst, + // long dstRegionOffset, int dstPos, int length) { + // if (length != 0) { + // long strideSizeInBytes = addressSize; + // + // if (USE_COPY_MEMORY) { + // unsafe.copyMemory(src, srcRegionOffset + srcPos * strideSizeInBytes, dst, + // dstRegionOffset + dstPos * strideSizeInBytes, length * strideSizeInBytes); + // } else { + // long srcOffset = srcRegionOffset + srcPos * strideSizeInBytes; + // long dstOffset = dstRegionOffset + dstPos * strideSizeInBytes; + // + // for (int i = 0; i < length; i++) { + // unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + // srcOffset += strideSizeInBytes; + // dstOffset += strideSizeInBytes; + // } + // } + // } + // } + + // static final void __rangecopyObjectRegion(long regionOffset, Object src, int srcPos, Object + // dst, + // int dstPos, int length) { + // long strideSizeInBytes = addressSize; + // + // unsafe.copyMemory(src, regionOffset + srcPos * strideSizeInBytes, dst, + // regionOffset + dstPos * strideSizeInBytes, length * strideSizeInBytes); + // } + + public static abstract class EitherIntOrObject { + + public enum Type { + INT, OBJECT + } + + public static final EitherIntOrObject ofInt(int value) { + return new EitherAsInt(value); + } + + public static final EitherIntOrObject ofObject(Object value) { + return new EitherAsObject(value); + } + + public abstract boolean isType(Type type); + + public abstract int getInt(); + + public abstract Object getObject(); + } + + public static final class EitherAsInt extends EitherIntOrObject { + + private final int value; + + private EitherAsInt(int value) { + this.value = value; + } + + @Override + public boolean isType(Type type) { + return type == Type.INT; + } + + @Override + public int getInt() { + return value; + } + + @Override + public Object getObject() { + throw new UnsupportedOperationException( + String.format("Requested type %s but actually found %s.", Type.OBJECT, Type.INT)); + } + } + + public static final class EitherAsObject extends EitherIntOrObject { + + private final Object value; + + private EitherAsObject(Object value) { + this.value = value; + } + + @Override + public boolean isType(Type type) { + return type == Type.OBJECT; + } + + @Override + public int getInt() { + throw new UnsupportedOperationException( + String.format("Requested type %s but actually found %s.", Type.INT, Type.OBJECT)); + } + + @Override + public Object getObject() { + return value; + } + } + + /* + * byte bitmaps + */ + + public static byte nodeMap(byte rawMap1, byte rawMap2) { + return (byte) (Byte.toUnsignedInt(rawMap1) ^ Byte.toUnsignedInt(rareMap(rawMap1, rawMap2))); + } + + public static byte nodeMap(byte rawMap1, byte rawMap2, byte rareMap) { + return (byte) (Byte.toUnsignedInt(rawMap1) ^ Byte.toUnsignedInt(rareMap)); + } + + public static byte dataMap(byte rawMap1, byte rawMap2) { + return (byte) (Byte.toUnsignedInt(rawMap2) ^ Byte.toUnsignedInt(rareMap(rawMap1, rawMap2))); + } + + public static byte dataMap(byte rawMap1, byte rawMap2, byte rareMap) { + return (byte) (Byte.toUnsignedInt(rawMap2) ^ Byte.toUnsignedInt(rareMap)); + } + + public static byte rareMap(byte rawMap1, byte rawMap2) { + return (byte) (Byte.toUnsignedInt(rawMap1) & Byte.toUnsignedInt(rawMap2)); + } + + public static int toState(byte rawMap1, byte rawMap2, byte bitpos) { + int bit1 = BitmapUtils.isBitInBitmap(rawMap1, bitpos) ? 1 : 0; + int bit2 = BitmapUtils.isBitInBitmap(rawMap2, bitpos) ? 2 : 0; + int bit = bit1 | bit2; + return bit; + } + + /* + * int bitmaps + */ + + public static int nodeMap(int rawMap1, int rawMap2) { + return rawMap1 ^ rareMap(rawMap1, rawMap2); + } + + public static int dataMap(int rawMap1, int rawMap2) { + return rawMap2 ^ rareMap(rawMap1, rawMap2); + } + + public static int rareMap(int rawMap1, int rawMap2) { + return rawMap1 & rawMap2; + } + + public static int toState(int rawMap1, int rawMap2, int bitpos) { + int bit1 = BitmapUtils.isBitInBitmap(rawMap1, bitpos) ? 1 : 0; + int bit2 = BitmapUtils.isBitInBitmap(rawMap2, bitpos) ? 2 : 0; + int bit = bit1 | bit2; + return bit; + } + + public static class Companion { + + final int nodeArity; + + final int payloadArity; + + final int slotArity; + + final int untypedSlotArity; + + final long rareBase; + + final long arrayOffsetLast; + + final long nodeBase; + + public Companion(int nodeArity, int payloadArity, int slotArity, int untypedSlotArity, + long rareBase, long arrayOffsetLast, long nodeBase) { + this.nodeArity = nodeArity; + this.payloadArity = payloadArity; + this.slotArity = slotArity; + this.untypedSlotArity = untypedSlotArity; + this.rareBase = rareBase; + this.arrayOffsetLast = arrayOffsetLast; + this.nodeBase = nodeBase; + } + + } + + public abstract static class AbstractArrayView { + + public AbstractArrayView(final Object base, final long offset, final int length) { + this.base = base; + this.offset = offset; + this.length = length; + } + + final Object base; + final long offset; + final int length; + + abstract Class getElementType(); + // abstract int getElementTypeLength(); + + abstract void set(int idx, Object value); + } + + public static class ObjectArrayView extends AbstractArrayView { + + public ObjectArrayView(Object base, long offset, int length) { + super(base, offset, length); + } + + @Override + Class getElementType() { + return Object.class; + } + + // @Override + // int getElementTypeLength() { + // return ...; + // } + + @Override + void set(int idx, Object value) { + setInObjectRegion(base, offset, idx, value); + } + + } + + public static class IntArrayView extends AbstractArrayView { + + public IntArrayView(Object base, long offset, int length) { + super(base, offset, length); + } + + @Override + Class getElementType() { + return Object.class; + } + + // @Override + // int getElementTypeLength() { + // return ...; + // } + + @Override + void set(int idx, Object value) { + if (!(value instanceof Integer)) { + throw new IllegalArgumentException(); + } + + setInIntRegion(base, offset, idx, (Integer) value); + } + + } + + /* + * final ArrayView getIntArrayView() { final Class clazz = this.getClass(); final int + * payloadArity = unsafe.getInt(clazz, globalPayloadArityOffset); + * + * return new IntArrayView(this, arrayBase, payloadArity * TUPLE_LENGTH); } + * + * final ArrayView getObjectArrayView() { final Class clazz = this.getClass(); final int + * untypedSlotArity = unsafe.getInt(clazz, globalUntypedSlotArityOffset); final long rareBase = + * unsafe.getLong(clazz, globalRareBaseOffset); + * + * return new ObjectArrayView(this, rareBase, untypedSlotArity); } + */ + + public static final void arrayviewcopyObject(Object src, int srcPos, Object dst, int dstPos, + int length) { + if (length != 0) { + AbstractArrayView srcView = (AbstractArrayView) src; + AbstractArrayView dstView = (AbstractArrayView) dst; + + _do_rangecopyObjectRegion(srcView.base, srcView.offset + srcPos * addressSize, dstView.base, + dstView.offset + dstPos * addressSize, length); + } + } + + public static final void arrayviewcopyInt(Object src, int srcPos, Object dst, int dstPos, + int length) { + if (length != 0) { + AbstractArrayView srcView = (AbstractArrayView) src; + AbstractArrayView dstView = (AbstractArrayView) dst; + + _do_rangecopyIntRegion(srcView.base, srcView.offset + srcPos * addressSize, dstView.base, + dstView.offset + dstPos * addressSize, length); + } + } + + public static final void arrayviewcopy(Object src, int srcPos, Object dst, int dstPos, + int length) { + if (length != 0) { + // if (!(src instanceof ArrayView && dst instanceof ArrayView)) + // throw new IllegalArgumentException(); + + AbstractArrayView srcView = (AbstractArrayView) src; + AbstractArrayView dstView = (AbstractArrayView) dst; + + // if (!(srcView.getElementType() == dstView.getElementType())) + // throw new IllegalArgumentException(); + + if (srcView.getElementType() == Object.class) { + _do_rangecopyObjectRegion(srcView.base, srcView.offset + srcPos * addressSize, dstView.base, + dstView.offset + dstPos * addressSize, length); + } else { + _do_rangecopyIntRegion(srcView.base, srcView.offset + srcPos * addressSize, dstView.base, + dstView.offset + dstPos * addressSize, length); + } + } + } + + // public static final long _do_rangecopyObjectRegion(Object src, long srcOffset, Object dst, + // long dstOffset, int length) { + // if (USE_COPY_MEMORY) { + // long strideSizeInBytes = addressSize; + // long sizeInBytes = length * strideSizeInBytes; + // unsafe.copyMemory(src, srcOffset, dst, dstOffset, sizeInBytes); + // return sizeInBytes; + // } else { + // long strideSizeInBytes = addressSize; + // long sizeInBytes = length * strideSizeInBytes; + // for (int i = 0; i < length; i++) { + // unsafe.putObject(dst, dstOffset, unsafe.getObject(src, srcOffset)); + // srcOffset += strideSizeInBytes; + // dstOffset += strideSizeInBytes; + // } + // return sizeInBytes; + // } + // + //// return sizeInBytes; + // } + + // long offset = src1.offset; + // + // offset += rangecopyObjectRegion(src2.base, offset, dst2.base, offset, idxOld2); + // offset += rangecopyObjectRegion(src2.base, offset + sizeOfObject() * TUPLE_LENGTH, dst2.base, + // offset, idxNew2 - idxOld2); + // offset += setInObjectRegionVarArgs(dst2.base, offset, node); + // offset += rangecopyObjectRegion(src2.base, offset + sizeOfObject(), dst2.base, offset, + // src2.length - idxNew2 - TUPLE_LENGTH); + + public static interface StreamingCopy { + + public static StreamingCopy streamingCopyTwoOffsets(ObjectArrayView from, ObjectArrayView to) { + return new StreamingCopyTwoOffsets(from, to); + } + + public static StreamingCopy streamingCopyOneOffset(ObjectArrayView from, ObjectArrayView to) { + return new StreamingCopyOneOffset(from, to); + } + + public void copy(int count); + + public void copyWithSrcForward(int count, int srcForward); + + public void copyWithDstForward(int count, int dstForward); + + public void copyWithSrcDstForward(int count, int srcForward, int dstForward); + + public void skipAtSrc(int count); + + public void skipAtDst(int count); + + public void insert(Object value); + + public void insertWithDstForward(Object value, int dstForward); + + public void put(Object value); + + } + + public static final class StreamingCopyTwoOffsets implements StreamingCopy { + + private final ObjectArrayView src; + private final ObjectArrayView dst; + + private long srcOffset; + private long dstOffset; + + private StreamingCopyTwoOffsets(ObjectArrayView src, ObjectArrayView dst) { + this.src = src; + this.dst = dst; + + srcOffset = src.offset; + dstOffset = dst.offset; + } + + void advance(long bytes) { + srcOffset += bytes; + dstOffset += bytes; + } + + @Override + public final void copy(int count) { + advance(rangecopyObjectRegion(src.base, srcOffset, dst.base, dstOffset, count)); + } + + @Override + public final void copyWithSrcForward(int count, int srcForward) { + advance(rangecopyObjectRegion(src.base, srcOffset + srcForward * addressSize, dst.base, + dstOffset, count)); + } + + @Override + public final void copyWithDstForward(int count, int dstForward) { + advance(rangecopyObjectRegion(src.base, srcOffset, dst.base, + dstOffset + dstForward * addressSize, count)); + } + + @Override + public final void copyWithSrcDstForward(int count, int srcForward, int dstForward) { + advance(rangecopyObjectRegion(src.base, srcOffset + srcForward * addressSize, dst.base, + dstOffset + dstForward * addressSize, count)); + } + + @Override + public final void skipAtSrc(int count) { + srcOffset += count * addressSize; + } + + @Override + public final void skipAtDst(int count) { + dstOffset += count * addressSize; + } + + @Override + public final void insert(Object value) { + dstOffset += setInObjectRegionVarArgs(dst.base, dstOffset, value); + } + + @Override + public final void insertWithDstForward(Object value, int dstForward) { + dstOffset += setInObjectRegionVarArgs(dst.base, dstOffset + dstForward * addressSize, value); + } + + @Override + public final void put(Object value) { + setInObjectRegionVarArgs(dst.base, dstOffset, value); + } + + // remainder(); + + } + + public static final class StreamingCopyOneOffset implements StreamingCopy { + + private final ObjectArrayView src; + private final ObjectArrayView dst; + + private long offset; + + StreamingCopyOneOffset(ObjectArrayView src, ObjectArrayView dst) { + this.src = src; + this.dst = dst; + + assert src.offset == dst.offset; + offset = src.offset; + } + + void advance(long bytes) { + offset += bytes; + } + + @Override + public final void copy(int count) { + advance(rangecopyObjectRegion(src.base, offset, dst.base, offset, count)); + } + + @Override + public final void copyWithSrcForward(int count, int srcForward) { + advance(rangecopyObjectRegion(src.base, offset + srcForward * addressSize, dst.base, offset, + count)); + } + + @Override + public final void copyWithDstForward(int count, int dstForward) { + advance(rangecopyObjectRegion(src.base, offset, dst.base, offset + dstForward * addressSize, + count)); + } + + @Override + public final void copyWithSrcDstForward(int count, int srcForward, int dstForward) { + advance(rangecopyObjectRegion(src.base, offset + srcForward * addressSize, dst.base, + offset + dstForward * addressSize, count)); + } + + @Override + public final void skipAtSrc(int count) { + // throw ... + } + + @Override + public final void skipAtDst(int count) { + // throw ... + } + + @Override + public final void insert(Object value) { + // throw ... + } + + @Override + public final void insertWithDstForward(Object value, int dstForward) { + offset += setInObjectRegionVarArgs(dst.base, offset + dstForward * addressSize, value); + } + + @Override + public final void put(Object value) { + setInObjectRegionVarArgs(dst.base, offset, value); + } + + // remainder(); + + } + +} diff --git a/capsule-veritas/capsule-veritas.iml b/capsule-veritas/capsule-veritas.iml new file mode 100644 index 0000000..939c1e5 --- /dev/null +++ b/capsule-veritas/capsule-veritas.iml @@ -0,0 +1,25 @@ + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/capsule-veritas/pom.xml b/capsule-veritas/pom.xml new file mode 100644 index 0000000..fac30fd --- /dev/null +++ b/capsule-veritas/pom.xml @@ -0,0 +1,71 @@ + + 4.0.0 + + + io.usethesource + capsule-pom-parent + 0.3.0.HETEROGENEOUS-SNAPSHOT + + + io.usethesource + capsule-veritas + 0.3.0.HETEROGENEOUS-SNAPSHOT + jar + + + ${project.parent.basedir} + + + + + + eu.somatik.serviceloader-maven-plugin + serviceloader-maven-plugin + 1.0.6 + + + com.pholser.junit.quickcheck.generator.Generator + + + + + + generate + + + + + + + + + + io.usethesource + capsule + 0.3.0.HETEROGENEOUS-SNAPSHOT + + + io.usethesource + capsule-experimental + 0.3.0.HETEROGENEOUS-SNAPSHOT + + + com.pholser + junit-quickcheck-core + 0.7 + + + com.pholser + junit-quickcheck-generators + 0.7 + + + junit + junit + 4.12 + + + + diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/AbstractBinaryRelationProperties.java b/capsule-veritas/src/main/java/io/usethesource/capsule/AbstractBinaryRelationProperties.java new file mode 100644 index 0000000..92c5179 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/AbstractBinaryRelationProperties.java @@ -0,0 +1,36 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.util.Map; +import java.util.stream.Stream; + +import com.pholser.junit.quickcheck.Property; + +import static org.junit.Assert.assertTrue; + +public abstract class AbstractBinaryRelationProperties> + extends AbstractSetMultimapProperties { + + public AbstractBinaryRelationProperties(Class type) { + super(type); + } + + @Property(trials = DEFAULT_TRIALS) + public void inverse(CT input) { + final BinaryRelation.Immutable inverseInput = + (BinaryRelation.Immutable) input.inverse(); + final Stream> entryStream = input.entrySet().stream(); + + boolean inverseContainsInversedTuples = + entryStream.allMatch(tuple -> inverseInput.containsEntry(tuple.getValue(), tuple.getKey())); + + assertTrue(inverseContainsInversedTuples); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/AbstractSetMultimapProperties.java b/capsule-veritas/src/main/java/io/usethesource/capsule/AbstractSetMultimapProperties.java new file mode 100644 index 0000000..628761b --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/AbstractSetMultimapProperties.java @@ -0,0 +1,161 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.util.HashSet; +import java.util.Map; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import com.pholser.junit.quickcheck.Property; +import com.pholser.junit.quickcheck.generator.Size; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +public abstract class AbstractSetMultimapProperties> { + + protected final int DEFAULT_TRIALS = 1_000; + protected final int MAX_SIZE = 1_000; + protected final Class type; + + public AbstractSetMultimapProperties(Class type) { + this.type = type; + } + + @Property(trials = DEFAULT_TRIALS) + public void convertToJavaSetAndCheckSize(CT input) { + assertEquals(new HashSet<>(input.entrySet()).size(), input.size()); + } + + @Property(trials = DEFAULT_TRIALS) + public void keySetEqualsKeyIteratorElements(final CT multimap) { + final java.util.Set keySet = new HashSet<>(); + multimap.keyIterator().forEachRemaining(keySet::add); + + // assertEquals(PersistentTrieSet.class, multimap.keySet().getClass()); + assertEquals(keySet, multimap.keySet()); + } + + // /** + // * TODO: replace batch construction by sequence of 'insert' operations + // */ + // @Property // (trials = DEFAULT_TRIALS) + // public void testInsertTuplesThatShareSameKey(final Integer key, + // @Size(min = 1, max = 100) final java.util.HashSet values) { + // assertEquals(values.size(), toMultimap(key, values).size()); + // assertTrue(toMultimap(key, values).containsKey(key)); + // } + // + // /** + // * TODO: replace batch construction by sequence of 'insert' operations followed by a 'remove' + // */ + // @Property(trials = DEFAULT_TRIALS) + // public void testInsertTuplesWithOneRemoveThatShareSameKeyX(final Integer key, + // @Size(min = 2, max = 100) final java.util.HashSet values) { + // + // Integer value = sourceOfRandomness.choose(values); + // SetMultimap.Immutable multimap = toMultimap(key, values); + // + // if (multimap.__remove(key, value).size() + 1 == multimap.size()) { + // // succeed + // multimap = multimap.__remove(key, value); + // } else { + // // fail + // assertTrue(multimap.containsEntry(key, value)); + // multimap = multimap.__remove(key, value); + // } + // + // // assertEquals(values.size() - 1, multimap.size()); + // // assertTrue(multimap.containsKey(key)); + // // values.forEach(currentValue -> { + // // if (!currentValue.equals(value)) { + // // assertTrue(multimap.containsEntry(key, currentValue)); + // // } + // // }); + // } + + /** + * Inserted tuple by tuple, starting from an empty multimap. Keeps track of all so far inserted + * tuples and checks after each insertion if all inserted tuples are contained (quadratic + * operation). + */ + @Property(trials = DEFAULT_TRIALS) + public void stepwiseContainsAfterInsert(@Size(min = 0, max = 0) final CT emptyCollection, + @Size(min = 1, max = MAX_SIZE) final java.util.HashSet> inputValues) { + + final HashSet> insertedValues = new HashSet<>(inputValues.size()); + CT testCollection = emptyCollection; + + for (Map.Entry newValueTuple : inputValues) { + final CT tmpCollection = + (CT) testCollection.__insert(newValueTuple.getKey(), newValueTuple.getValue()); + insertedValues.add(newValueTuple); + + boolean containsInsertedValues = insertedValues.stream() + .allMatch(tuple -> tmpCollection.containsEntry(tuple.getKey(), tuple.getValue())); + + assertTrue("All so far inserted values must be contained.", containsInsertedValues); + // String.format("%s.insert(%s)", testSet, newValue); + + testCollection = tmpCollection; + } + } + + @Property(trials = DEFAULT_TRIALS) + public void containsAfterInsert(@Size(min = 0, max = 0) final CT emptyCollection, + @Size(min = 1, max = MAX_SIZE) final java.util.HashSet> inputValues) { + + CT testCollection = emptyCollection; + + for (Map.Entry newValueTuple : inputValues) { + final CT tmpCollection = + (CT) testCollection.__insert(newValueTuple.getKey(), newValueTuple.getValue()); + testCollection = tmpCollection; + } + + final CT finalCollection = testCollection; + + boolean containsInsertedValues = inputValues.stream() + .allMatch(tuple -> finalCollection.containsEntry(tuple.getKey(), tuple.getValue())); + + assertTrue("Must contain all inserted values.", containsInsertedValues); + } + + @Property(trials = DEFAULT_TRIALS) + public void notContainedAfterInsertRemove(CT input, K item0, V item1) { + assertFalse(input.__insert(item0, item1).__remove(item0, item1).containsEntry(item0, item1)); + } + + @Property(trials = DEFAULT_TRIALS) + public void entryIteratorAfterInsert(@Size(min = 0, max = 0) final CT emptyCollection, + @Size(min = 1, max = MAX_SIZE) final java.util.HashSet> inputValues) { + + CT testCollection = emptyCollection; + + for (Map.Entry newValueTuple : inputValues) { + final CT tmpCollection = + (CT) testCollection.__insert(newValueTuple.getKey(), newValueTuple.getValue()); + testCollection = tmpCollection; + } + + final CT finalCollection = testCollection; + + final Spliterator entrySpliterator = Spliterators + .spliterator(finalCollection.entryIterator(), finalCollection.size(), Spliterator.DISTINCT); + final Stream entryStream = StreamSupport.stream(entrySpliterator, false); + + boolean containsInsertedValues = entryStream.allMatch(inputValues::contains); + + assertTrue("Must contain all inserted values.", containsInsertedValues); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/AbstractSetProperties.java b/capsule-veritas/src/main/java/io/usethesource/capsule/AbstractSetProperties.java new file mode 100644 index 0000000..7bf760a --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/AbstractSetProperties.java @@ -0,0 +1,104 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.util.HashSet; + +import com.pholser.junit.quickcheck.Property; +import com.pholser.junit.quickcheck.generator.Size; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +public abstract class AbstractSetProperties> { + + private final int DEFAULT_TRIALS = 1_000; + private final int MAX_SIZE = 1_000; + private final Class type; + + public AbstractSetProperties(Class type) { + this.type = type; + } + + @Property(trials = DEFAULT_TRIALS) + public void convertToJavaSetAndCheckSize(CT input) { + assertEquals(new HashSet(input).size(), input.size()); + } + + @Property(trials = DEFAULT_TRIALS) + public void convertToJavaSetAndCheckHashCode(CT input) { + assertEquals(new HashSet(input).hashCode(), input.hashCode()); + } + + @Property(trials = DEFAULT_TRIALS) + public void convertToJavaSetAndCheckEquality(CT input) { + assertEquals("input.equals(convertToJavaSet)", input, new HashSet(input)); + assertEquals("convertToJavaSet.equals(input)", new HashSet(input), input); + } + + @Property(trials = DEFAULT_TRIALS) + public void streamYieldsSizeElements(CT input) { + assertEquals(input.size(), input.stream().count()); + } + + @Property(trials = DEFAULT_TRIALS) + public void checkSizeAfterInsertAll(@Size(min = 0, max = 0) final CT emptySet, + java.util.HashSet inputValues) { + CT testSet = (CT) emptySet.__insertAll(inputValues); + assertEquals(inputValues.size(), testSet.size()); + } + + /** + * Inserted element by element, starting from an empty set. Keeps track of all so far inserted + * values and checks after each insertion if all inserted elements are contained (quadratic + * operation). + */ + @Property(trials = DEFAULT_TRIALS) + public void stepwiseContainsAfterInsert(@Size(min = 0, max = 0) final CT emptySet, + @Size(min = 1, max = MAX_SIZE) final java.util.HashSet inputValues) { + + final HashSet insertedValues = new HashSet<>(inputValues.size()); + CT testSet = emptySet; + + for (T newValue : inputValues) { + final CT tmpSet = (CT) testSet.__insert(newValue); + insertedValues.add(newValue); + + boolean containsInsertedValues = + insertedValues.stream().allMatch(tmpSet::contains); + + assertTrue("All so far inserted values must be contained.", containsInsertedValues); + // String.format("%s.insert(%s)", testSet, newValue); + + testSet = tmpSet; + } + } + + @Property(trials = DEFAULT_TRIALS) + public void containsAfterInsert(@Size(min = 0, max = 0) final CT emptySet, + @Size(min = 1, max = MAX_SIZE) final java.util.HashSet inputValues) { + + CT testSet = emptySet; + + for (T newValue : inputValues) { + final CT tmpSet = (CT) testSet.__insert(newValue); + testSet = tmpSet; + } + + boolean containsInsertedValues = inputValues.stream().allMatch(testSet::contains); + + assertTrue("Must contain all inserted values.", containsInsertedValues); + } + + @Property(trials = DEFAULT_TRIALS) + public void notContainedAfterInsertRemove(CT input, T item) { + assertFalse(input.__insert(item).__remove(item).contains(item)); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/AbstractTernaryRelationProperties.java b/capsule-veritas/src/main/java/io/usethesource/capsule/AbstractTernaryRelationProperties.java new file mode 100644 index 0000000..ccfea98 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/AbstractTernaryRelationProperties.java @@ -0,0 +1,20 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import io.usethesource.capsule.api.TernaryRelation; +import io.usethesource.capsule.api.Triple; + +public abstract class AbstractTernaryRelationProperties extends + AbstractSetProperties, TernaryRelation.Immutable>> { + + public AbstractTernaryRelationProperties(Class type) { + super(type); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/MapEntryGenerator.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/MapEntryGenerator.java new file mode 100644 index 0000000..eda2e1c --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/MapEntryGenerator.java @@ -0,0 +1,39 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators; + +import java.util.Map; + +import com.pholser.junit.quickcheck.generator.ComponentizedGenerator; +import com.pholser.junit.quickcheck.generator.GenerationStatus; +import com.pholser.junit.quickcheck.random.SourceOfRandomness; + +import static io.usethesource.capsule.util.collection.AbstractSpecialisedImmutableMap.entryOf; + +@SuppressWarnings({"rawtypes", "unchecked"}) +public final class MapEntryGenerator + extends ComponentizedGenerator { + + public MapEntryGenerator() { + super((Class) Map.Entry.class); + } + + @Override + public int numberOfNeededComponents() { + return 2; + } + + @Override + public T generate(SourceOfRandomness random, GenerationStatus status) { + Object item0 = componentGenerators().get(0).generate(random, status); + Object item1 = componentGenerators().get(1).generate(random, status); + + return (T) entryOf(item0, item1); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/SingletonToTripleGenerator.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/SingletonToTripleGenerator.java new file mode 100644 index 0000000..9d1e375 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/SingletonToTripleGenerator.java @@ -0,0 +1,35 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators; + +import com.pholser.junit.quickcheck.generator.ComponentizedGenerator; +import com.pholser.junit.quickcheck.generator.GenerationStatus; +import com.pholser.junit.quickcheck.random.SourceOfRandomness; +import io.usethesource.capsule.api.Triple; + +@SuppressWarnings({"rawtypes", "unchecked"}) +public final class SingletonToTripleGenerator + extends ComponentizedGenerator { + + public SingletonToTripleGenerator() { + super((Class) Triple.class); + } + + @Override + public int numberOfNeededComponents() { + return 1; + } + + @Override + public T generate(SourceOfRandomness random, GenerationStatus status) { + final Object item0 = componentGenerators().get(0).generate(random, status); + + return (T) Triple.of(item0, item0, item0); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/TripleGenerator.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/TripleGenerator.java new file mode 100644 index 0000000..15f50dd --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/TripleGenerator.java @@ -0,0 +1,37 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators; + +import com.pholser.junit.quickcheck.generator.ComponentizedGenerator; +import com.pholser.junit.quickcheck.generator.GenerationStatus; +import com.pholser.junit.quickcheck.random.SourceOfRandomness; +import io.usethesource.capsule.api.Triple; + +@SuppressWarnings({"rawtypes", "unchecked"}) +public final class TripleGenerator + extends ComponentizedGenerator { + + public TripleGenerator() { + super((Class) Triple.class); + } + + @Override + public int numberOfNeededComponents() { + return 3; + } + + @Override + public T generate(SourceOfRandomness random, GenerationStatus status) { + Object item0 = componentGenerators().get(0).generate(random, status); + Object item1 = componentGenerators().get(1).generate(random, status); + Object item2 = componentGenerators().get(2).generate(random, status); + + return (T) Triple.of(item0, item1, item2); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/AbstractSetMultimapGenerator.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/AbstractSetMultimapGenerator.java new file mode 100644 index 0000000..e9c8397 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/AbstractSetMultimapGenerator.java @@ -0,0 +1,138 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.multimap; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import com.pholser.junit.quickcheck.generator.ComponentizedGenerator; +import com.pholser.junit.quickcheck.generator.GenerationStatus; +import com.pholser.junit.quickcheck.generator.Size; +import com.pholser.junit.quickcheck.random.SourceOfRandomness; +import io.usethesource.capsule.SetMultimap; + +import static com.pholser.junit.quickcheck.internal.Ranges.Type.INTEGRAL; +import static com.pholser.junit.quickcheck.internal.Ranges.checkRange; + +public abstract class AbstractSetMultimapGenerator + extends ComponentizedGenerator { + + private Class target; + private Size sizeRange; + + public AbstractSetMultimapGenerator(Class target) { + super(target); + this.target = target; + } + + public void configure(Size size) { + this.sizeRange = size; + checkRange(INTEGRAL, size.min(), size.max()); + } + + protected final int size(SourceOfRandomness random, GenerationStatus status) { + return sizeRange != null ? random.nextInt(sizeRange.min(), sizeRange.max()) : status.size(); + } + + protected T empty() { + try { + final Method persistentSetOfEmpty = target.getMethod("of"); + return (T) persistentSetOfEmpty.invoke(null); + } catch (NoSuchMethodException | SecurityException | IllegalAccessException + | IllegalArgumentException | InvocationTargetException e) { + throw new RuntimeException(); + } + } + + @Override + public int numberOfNeededComponents() { + return 2; + } + + @Override + public T generate(SourceOfRandomness random, GenerationStatus status) { + int size = size(random, status); + + T items = empty(); + + final int oneToOneStepSize = 2; + final int oneToManySetSize = 2; + + int i = size - 1; + while (i >= 0) { + final Object item0 = componentGenerators().get(0).generate(random, status); + + final int generatedTuplesCount; + if (i % oneToOneStepSize == 0) { + final Object item1 = componentGenerators().get(1).generate(random, status); + items = (T) items.__insert(item0, item1); + + generatedTuplesCount = 1; + } else { + for (int j = oneToManySetSize - 1; j >= 0 && i >= 0; j--) { + final Object item1 = componentGenerators().get(1).generate(random, status); + items = (T) items.__insert(item0, item1); + } + + generatedTuplesCount = oneToManySetSize; + } + + i = i - generatedTuplesCount; + } + + return items; + } + + @Override + public boolean canShrink(Object larger) { + return false; + } + + // @Override public List doShrink(SourceOfRandomness random, T larger) { + // @SuppressWarnings("unchecked") + // List asList = new ArrayList<>(larger.entrySet()); + // + // List shrinks = new ArrayList<>(); + // shrinks.addAll(removals(asList)); + // + // @SuppressWarnings("unchecked") + // Shrink generator = (Shrink) componentGenerators().get(0); + // + // List> oneItemShrinks = shrinksOfOneItem(random, asList, generator); + // shrinks.addAll(oneItemShrinks.stream() + // .map(this::convert) + // .filter(this::inSizeRange) + // .collect(Collectors.toList())); + // + // return shrinks; + // } + + private boolean inSizeRange(T items) { + return sizeRange == null + || (items.size() >= sizeRange.min() && items.size() <= sizeRange.max()); + } + + // private List removals(List items) { + // return stream(halving(items.size()).spliterator(), false) + // .map(i -> removeFrom(items, i)) + // .flatMap(Collection::stream) + // .map(this::convert) + // .filter(this::inSizeRange) + // .collect(Collectors.toList()); + // } + // + // @SuppressWarnings("unchecked") + // private T convert(List items) { + // T converted = empty(); + // for (Object item : items) { + // converted = (T) converted.__insert(item); + // } + // return converted; + // } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_ChampBasedPrototype.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_ChampBasedPrototype.java new file mode 100644 index 0000000..f405793 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_ChampBasedPrototype.java @@ -0,0 +1,20 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.multimap; + +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_ChampBasedPrototype; + +@SuppressWarnings({"rawtypes"}) +public class SetMultimapGenerator_ChampBasedPrototype + extends AbstractSetMultimapGenerator { + + public SetMultimapGenerator_ChampBasedPrototype() { + super(TrieSetMultimap_ChampBasedPrototype.class); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HCHAMP.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HCHAMP.java new file mode 100644 index 0000000..98762ed --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HCHAMP.java @@ -0,0 +1,19 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.multimap; + +import io.usethesource.capsule.core.PersistentTrieSetMultimap; + +public class SetMultimapGenerator_HCHAMP + extends AbstractSetMultimapGenerator { + + public SetMultimapGenerator_HCHAMP() { + super(PersistentTrieSetMultimap.class); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT.java new file mode 100644 index 0000000..94a286c --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT.java @@ -0,0 +1,20 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.multimap; + +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT; + +@SuppressWarnings({"rawtypes"}) +public class SetMultimapGenerator_HHAMT + extends AbstractSetMultimapGenerator { + + public SetMultimapGenerator_HHAMT() { + super(TrieSetMultimap_HHAMT.class); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT_Interlinked.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT_Interlinked.java new file mode 100644 index 0000000..c4cf46b --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT_Interlinked.java @@ -0,0 +1,20 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.multimap; + +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Interlinked; + +@SuppressWarnings({"rawtypes"}) +public class SetMultimapGenerator_HHAMT_Interlinked + extends AbstractSetMultimapGenerator { + + public SetMultimapGenerator_HHAMT_Interlinked() { + super(TrieSetMultimap_HHAMT_Interlinked.class); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT_Specialized.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT_Specialized.java new file mode 100644 index 0000000..ed5b656 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT_Specialized.java @@ -0,0 +1,20 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.multimap; + +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized; + +@SuppressWarnings({"rawtypes"}) +public class SetMultimapGenerator_HHAMT_Specialized + extends AbstractSetMultimapGenerator { + + public SetMultimapGenerator_HHAMT_Specialized() { + super(TrieSetMultimap_HHAMT_Specialized.class); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT_Specialized_Interlinked.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT_Specialized_Interlinked.java new file mode 100644 index 0000000..f99f109 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT_Specialized_Interlinked.java @@ -0,0 +1,20 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.multimap; + +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized_Interlinked; + +@SuppressWarnings({"rawtypes"}) +public class SetMultimapGenerator_HHAMT_Specialized_Interlinked + extends AbstractSetMultimapGenerator { + + public SetMultimapGenerator_HHAMT_Specialized_Interlinked() { + super(TrieSetMultimap_HHAMT_Specialized_Interlinked.class); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT_Specialized_Path_Interlinked.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT_Specialized_Path_Interlinked.java new file mode 100644 index 0000000..543f8f4 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/multimap/SetMultimapGenerator_HHAMT_Specialized_Path_Interlinked.java @@ -0,0 +1,20 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.multimap; + +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized_Path_Interlinked; + +@SuppressWarnings({"rawtypes"}) +public class SetMultimapGenerator_HHAMT_Specialized_Path_Interlinked + extends AbstractSetMultimapGenerator { + + public SetMultimapGenerator_HHAMT_Specialized_Path_Interlinked() { + super(TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.class); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/relation/AbstractTernaryRelationGenerator.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/relation/AbstractTernaryRelationGenerator.java new file mode 100644 index 0000000..804fd74 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/relation/AbstractTernaryRelationGenerator.java @@ -0,0 +1,123 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.relation; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.stream.Collectors; + +import com.pholser.junit.quickcheck.generator.ComponentizedGenerator; +import com.pholser.junit.quickcheck.generator.GenerationStatus; +import com.pholser.junit.quickcheck.generator.Shrink; +import com.pholser.junit.quickcheck.generator.Size; +import com.pholser.junit.quickcheck.random.SourceOfRandomness; +import io.usethesource.capsule.api.TernaryRelation; + +import static com.pholser.junit.quickcheck.internal.Lists.removeFrom; +import static com.pholser.junit.quickcheck.internal.Lists.shrinksOfOneItem; +import static com.pholser.junit.quickcheck.internal.Ranges.Type.INTEGRAL; +import static com.pholser.junit.quickcheck.internal.Ranges.checkRange; +import static com.pholser.junit.quickcheck.internal.Sequences.halving; +import static java.util.stream.StreamSupport.stream; + +@SuppressWarnings({"rawtypes", "unchecked"}) +public abstract class AbstractTernaryRelationGenerator + extends ComponentizedGenerator { + + private Class target; + private Size sizeRange; + + public AbstractTernaryRelationGenerator(Class target) { + super(target); + this.target = target; + } + + public void configure(Size size) { + this.sizeRange = size; + checkRange(INTEGRAL, size.min(), size.max()); + } + + protected final int size(SourceOfRandomness random, GenerationStatus status) { + return sizeRange != null ? random.nextInt(sizeRange.min(), sizeRange.max()) : status.size(); + } + + protected T empty() { + try { + final Method persistentSetOfEmpty = target.getMethod("of"); + return (T) persistentSetOfEmpty.invoke(null); + } catch (NoSuchMethodException | SecurityException | IllegalAccessException + | IllegalArgumentException | InvocationTargetException e) { + throw new RuntimeException(); + } + } + + @Override + public int numberOfNeededComponents() { + return 4; + } + + @Override + public T generate(SourceOfRandomness random, GenerationStatus status) { + int size = size(random, status); + + T items = empty(); + for (int i = 0; i < size; ++i) { + // Object item0 = componentGenerators().get(0).generate(random, status); + // Object item1 = componentGenerators().get(1).generate(random, status); + // Object item2 = componentGenerators().get(2).generate(random, status); + + Object triple = componentGenerators().get(3).generate(random, status); + + items = (T) items.__insert(triple); + } + + return items; + } + + @Override + public List doShrink(SourceOfRandomness random, T larger) { + @SuppressWarnings("unchecked") + List asList = new ArrayList<>(larger); + + List shrinks = new ArrayList<>(); + shrinks.addAll(removals(asList)); + + @SuppressWarnings("unchecked") + Shrink generator = (Shrink) componentGenerators().get(0); + + List> oneItemShrinks = shrinksOfOneItem(random, asList, generator); + shrinks.addAll(oneItemShrinks.stream().map(this::convert).filter(this::inSizeRange) + .collect(Collectors.toList())); + + return shrinks; + } + + private boolean inSizeRange(T items) { + return sizeRange == null + || (items.size() >= sizeRange.min() && items.size() <= sizeRange.max()); + } + + private List removals(List items) { + return stream(halving(items.size()).spliterator(), false).map(i -> removeFrom(items, i)) + .flatMap(Collection::stream).map(this::convert).filter(this::inSizeRange) + .collect(Collectors.toList()); + } + + @SuppressWarnings("unchecked") + private T convert(List items) { + T converted = empty(); + for (Object item : items) { + converted = (T) converted.__insert(item); + } + return converted; + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/relation/BidirectionalTrieSetMultimapGenerator.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/relation/BidirectionalTrieSetMultimapGenerator.java new file mode 100644 index 0000000..9da3b03 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/relation/BidirectionalTrieSetMultimapGenerator.java @@ -0,0 +1,20 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.relation; + +import io.usethesource.capsule.core.PersistentBidirectionalTrieSetMultimap; +import io.usethesource.capsule.generators.multimap.AbstractSetMultimapGenerator; + +public class BidirectionalTrieSetMultimapGenerator + extends AbstractSetMultimapGenerator { + + public BidirectionalTrieSetMultimapGenerator() { + super(PersistentBidirectionalTrieSetMultimap.class); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/relation/TernaryTrieSetMultimapGenerator.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/relation/TernaryTrieSetMultimapGenerator.java new file mode 100644 index 0000000..063f02e --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/relation/TernaryTrieSetMultimapGenerator.java @@ -0,0 +1,20 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.relation; + +import io.usethesource.capsule.experimental.relation.TernaryTrieSetMultimap; + +@SuppressWarnings({"rawtypes"}) +public class TernaryTrieSetMultimapGenerator + extends AbstractTernaryRelationGenerator { + + public TernaryTrieSetMultimapGenerator() { + super(TernaryTrieSetMultimap.class); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/AbstractSetGenerator.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/AbstractSetGenerator.java new file mode 100644 index 0000000..105e81e --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/AbstractSetGenerator.java @@ -0,0 +1,119 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.set; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.stream.Collectors; + +import com.pholser.junit.quickcheck.generator.ComponentizedGenerator; +import com.pholser.junit.quickcheck.generator.GenerationStatus; +import com.pholser.junit.quickcheck.generator.Shrink; +import com.pholser.junit.quickcheck.generator.Size; +import com.pholser.junit.quickcheck.random.SourceOfRandomness; +import io.usethesource.capsule.Set; + +import static com.pholser.junit.quickcheck.internal.Lists.removeFrom; +import static com.pholser.junit.quickcheck.internal.Lists.shrinksOfOneItem; +import static com.pholser.junit.quickcheck.internal.Ranges.Type.INTEGRAL; +import static com.pholser.junit.quickcheck.internal.Ranges.checkRange; +import static com.pholser.junit.quickcheck.internal.Sequences.halving; +import static java.util.stream.StreamSupport.stream; + +public abstract class AbstractSetGenerator + extends ComponentizedGenerator { + + private Class target; + private Size sizeRange; + + public AbstractSetGenerator(Class target) { + super(target); + this.target = target; + } + + public void configure(Size size) { + this.sizeRange = size; + checkRange(INTEGRAL, size.min(), size.max()); + } + + protected final int size(SourceOfRandomness random, GenerationStatus status) { + return sizeRange != null ? random.nextInt(sizeRange.min(), sizeRange.max()) : status.size(); + } + + protected T empty() { + try { + final Method persistentSetOfEmpty = target.getMethod("of"); + return (T) persistentSetOfEmpty.invoke(null); + } catch (NoSuchMethodException | SecurityException | IllegalAccessException + | IllegalArgumentException | InvocationTargetException e) { + throw new RuntimeException(); + } + } + + @Override + public int numberOfNeededComponents() { + return 1; + } + + @Override + public T generate(SourceOfRandomness random, GenerationStatus status) { + int size = size(random, status); + + T items = empty(); + for (int i = 0; i < size; ++i) { + Object item = componentGenerators().get(0).generate(random, status); + items = (T) items.__insert(item); + } + + return items; + } + + @Override + public List doShrink(SourceOfRandomness random, T larger) { + List asList = new ArrayList<>(larger); + + List shrinks = new ArrayList<>(); + shrinks.addAll(removals(asList)); + + Shrink generator = (Shrink) componentGenerators().get(0); + + List> oneItemShrinks = shrinksOfOneItem(random, asList, generator); + shrinks.addAll(oneItemShrinks.stream() + .map(this::convert) + .filter(this::inSizeRange) + .collect(Collectors.toList())); + + return shrinks; + } + + private boolean inSizeRange(T items) { + return sizeRange == null + || (items.size() >= sizeRange.min() && items.size() <= sizeRange.max()); + } + + private List removals(List items) { + return stream(halving(items.size()).spliterator(), false) + .map(i -> removeFrom(items, i)) + .flatMap(Collection::stream) + .map(this::convert) + .filter(this::inSizeRange) + .collect(Collectors.toList()); + } + + private T convert(List items) { + T converted = empty(); + for (Object item : items) { + converted = (T) converted.__insert(item); + } + return converted; + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetGeneratorDefault.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetGeneratorDefault.java new file mode 100644 index 0000000..5ce2fc0 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetGeneratorDefault.java @@ -0,0 +1,19 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.set; + +import io.usethesource.capsule.Set; +import io.usethesource.capsule.core.PersistentTrieSet; + +public class SetGeneratorDefault extends AbstractSetGenerator { + + public SetGeneratorDefault() { + super((Class) PersistentTrieSet.class); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetGeneratorLazyHashCode.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetGeneratorLazyHashCode.java new file mode 100644 index 0000000..533fe7c --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetGeneratorLazyHashCode.java @@ -0,0 +1,19 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.set; + +import io.usethesource.capsule.experimental.lazy.TrieSet_5Bits_LazyHashCode; + +@SuppressWarnings({"rawtypes"}) +public class SetGeneratorLazyHashCode extends AbstractSetGenerator { + + public SetGeneratorLazyHashCode() { + super(TrieSet_5Bits_LazyHashCode.class); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetGeneratorMemoizedLazyHashCode.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetGeneratorMemoizedLazyHashCode.java new file mode 100644 index 0000000..f4b1a61 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetGeneratorMemoizedLazyHashCode.java @@ -0,0 +1,20 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.set; + +import io.usethesource.capsule.experimental.memoized.TrieSet_5Bits_Memoized_LazyHashCode; + +@SuppressWarnings({"rawtypes"}) +public class SetGeneratorMemoizedLazyHashCode + extends AbstractSetGenerator { + + public SetGeneratorMemoizedLazyHashCode() { + super(TrieSet_5Bits_Memoized_LazyHashCode.class); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetGeneratorSpec0To8.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetGeneratorSpec0To8.java new file mode 100644 index 0000000..acdda48 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetGeneratorSpec0To8.java @@ -0,0 +1,19 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.set; + +import io.usethesource.capsule.experimental.specialized.TrieSet_5Bits_Spec0To8; + +@SuppressWarnings({"rawtypes"}) +public class SetGeneratorSpec0To8 extends AbstractSetGenerator { + + public SetGeneratorSpec0To8() { + super(TrieSet_5Bits_Spec0To8.class); + } + +} diff --git a/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetToLegacySetGenerator.java b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetToLegacySetGenerator.java new file mode 100644 index 0000000..f0fb975 --- /dev/null +++ b/capsule-veritas/src/main/java/io/usethesource/capsule/generators/set/SetToLegacySetGenerator.java @@ -0,0 +1,51 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule.generators.set; + +import com.pholser.junit.quickcheck.generator.GenerationStatus; +import com.pholser.junit.quickcheck.random.SourceOfRandomness; +import io.usethesource.capsule.core.converter.SetToLegacySetConverter; +import io.usethesource.capsule.core.experimental.TrieSet; + +@SuppressWarnings({"rawtypes", "unchecked"}) +public class SetToLegacySetGenerator extends AbstractSetGenerator> { + + public SetToLegacySetGenerator() { + super((Class) SetToLegacySetConverter.class); + } + + @Override + protected final SetToLegacySetConverter empty() { + return (SetToLegacySetConverter) SetToLegacySetConverter.adapt(TrieSet.of()); + } + + @Override + public int numberOfNeededComponents() { + return 1; + } + + // TODO: check shrinking support in hierarchy + @Override + public boolean canShrink(Object larger) { + return false; + } + + @Override + public SetToLegacySetConverter generate(SourceOfRandomness random, GenerationStatus status) { + int size = size(random, status); + + SetToLegacySetConverter items = empty(); + for (int i = 0; i < size; ++i) { + K item = (K) componentGenerators().get(0).generate(random, status); + items = (SetToLegacySetConverter) items.__insert(item); + } + + return items; + } + +} diff --git a/capsule-veritas/src/test/java/io/usethesource/capsule/HeterogeneousApiExampleTest.java b/capsule-veritas/src/test/java/io/usethesource/capsule/HeterogeneousApiExampleTest.java new file mode 100644 index 0000000..9c4ea29 --- /dev/null +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/HeterogeneousApiExampleTest.java @@ -0,0 +1,215 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.math.BigInteger; +import java.util.function.Consumer; + +import org.junit.Ignore; +import org.junit.Test; + +@Ignore +public class HeterogeneousApiExampleTest { + + @Test + public void testIntAndBigIntSetImpl() { + IntAndBigIntSetImpl impl = new IntAndBigIntSetImpl(); + impl.add(new EitherIntOrGeneric()); + impl.add(BigInteger.ZERO); + impl.add(1); + System.out.println(); + } + + @Test + public void testSetImpl() { + SetImpl impl = new SetImpl<>(); + impl.add(new Integer(5)); + impl.add(BigInteger.ZERO); + impl.add(1); + System.out.println(); + } + + @Test + public void testSetImpl2() { + SetImpl impl = new SetImpl<>(); + impl.add(new Integer(5)); + impl.add(BigInteger.ZERO); + impl.add(1); + System.out.println(); + } + + @Test + public void heterogeneousInterfaceTest() { + put(String.class, "abc", int.class, 5); + put(String.class, "abc", Integer.class, 5); + + put(String.class, "abc", long.class, 5L); + put(String.class, "abc", Long.class, 5L); + } + + static void put(Class keyType, T keyInstance, Class valueType, U valueInstance) { + System.out.println(); + + System.out.println(keyType.getName()); + System.out.println(valueType.getName()); + + switch (keyType.getName()) { + case "java.lang.String": + switch (valueType.getName()) { + case "int": + put((String) keyType.cast(keyInstance), (int) (Integer) valueInstance); + return; + case "java.lang.Integer": + put((String) keyType.cast(keyInstance), (Integer) valueInstance); + return; + } + } + + System.out.println("Unsupported Type"); + } + + static void put(String keyInstance, Integer valueInstance) { + System.out.println("put(String keyInstance, Integer valueInstance)"); + // System.out.println(keyInstance); + // System.out.println(valueInstance); + } + + static void put(String keyInstance, int valueInstance) { + System.out.println("put(String keyInstance, int valueInstance)"); + // System.out.println(keyInstance); + // System.out.println(valueInstance); + } + +} + + +class Either2 { + +} + + +class EitherIntOrGeneric { + +} + + +class IntAndBigIntSetImpl implements IntAndBigIntSet { + + @Override + public boolean add(EitherIntOrGeneric e) { + System.out.println("IntAndBigIntSetImpl.add(EitherIntOrGeneric)"); + return true; + } + + @Override + public boolean add(BigInteger value) { + System.out.println("IntAndBigIntSetImpl.add(BigInteger)"); + return true; + } + + @Override + public boolean add(int value) { + System.out.println("IntAndBigIntSetImpl.add(int)"); + return true; + } + +} + + +interface IntAndBigIntSet extends SetInterface> { + + @Override + boolean add(EitherIntOrGeneric e); + + boolean add(BigInteger value); + + // @Override + // boolean add(int value); + +} + + +class SetImpl implements SetInterface { + + @Override + public boolean add(E value) { + System.out.println("SetImpl.add(E)"); + return true; + } + + @Override + public boolean add(int value) { + System.out.println("SetImpl.add(int)"); + return true; + } + +} + + +interface SetInterface extends Collection { + + boolean add(E e); + + default boolean add(int value) { + try { + @SuppressWarnings("unchecked") + E typedValue = ((E) Integer.valueOf(value)); + return add(typedValue); + } catch (ClassCastException e) { + return false; + } + } + +} + + +interface Collection { // extends Iterable { + + boolean add(E e); + +} + + +interface HeterogeneousSet { + boolean add(Class elementType, E element); + + boolean remove(Class elementType, E element); + + boolean contains(Class elementType, E element); +} + + +interface HeterogeneousMap { + // pull-based dispatch on type + TypedObject put(Class keyType, K key, Class valueType, V value); + + TypedObject remove(Class keyType, K key); + + TypedObject get(Class keyType, K key); + + // push-based dispatch on type + void put(Class keyType, K key, Class valueType, V value, CallbackMap callbacks); + + void remove(Class keyType, K key, Class valueType, V value, CallbackMap callbacks); + + void get(Class keyType, K key, Class valueType, V value, CallbackMap callbacks); +} + + +interface TypedObject { + Class getType(); + + T get(); +} + + +interface CallbackMap { + Consumer put(Class elementType, Consumer consumer); + + Consumer get(Class elementType); +} diff --git a/capsule-veritas/src/test/java/io/usethesource/capsule/HeterogeneousMapSmokeTest.java b/capsule-veritas/src/test/java/io/usethesource/capsule/HeterogeneousMapSmokeTest.java new file mode 100644 index 0000000..033e6e3 --- /dev/null +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/HeterogeneousMapSmokeTest.java @@ -0,0 +1,137 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.math.BigInteger; +import java.util.Random; + +import io.usethesource.capsule.experimental.heterogeneous.TrieMap_Heterogeneous_BleedingEdge; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +public class HeterogeneousMapSmokeTest { + + final static int size = 2097152; + // final static int size = (int) Math.pow(2, 10); + + @Test + public void testPrintStatsRandomSmallAndBigIntegers() { + TrieMap_Heterogeneous_BleedingEdge map = + (TrieMap_Heterogeneous_BleedingEdge) TrieMap_Heterogeneous_BleedingEdge.of(); + long smallCount = 0; + long bigCount = 0; + + Random rand = new Random(13); + + for (int i = size; i > 0; i--) { + final int j = rand.nextInt(); + // System.out.println(j); + + final BigInteger bigJ = BigInteger.valueOf(j).multiply(BigInteger.valueOf(j)); + // System.out.println(bigJ); + + final Integer boxedJ = Integer.valueOf(j); + // System.out.println(boxedJ); + + if (i % 20 == 0) { // earlier: bigJ.bitLength() > 31 + // System.out.println("BIG"); + bigCount++; + + TrieMap_Heterogeneous_BleedingEdge res = + (TrieMap_Heterogeneous_BleedingEdge) map.__put(bigJ, bigJ); + assert res.containsKey(bigJ); + + // TrieMap_Heterogeneous_BleedingEdge res = + // (TrieMap_Heterogeneous_BleedingEdge) map.__put(boxedJ, boxedJ); + // assertTrue(res.containsKey(boxedJ)); + // because of non-overlap constraint + // assertTrue(res.containsKey(j) || res.containsKey(boxedJ)); + + map = res; + } else { + // System.out.println("SMALL"); + smallCount++; + TrieMap_Heterogeneous_BleedingEdge res = + (TrieMap_Heterogeneous_BleedingEdge) map.__put(j, j); + assertTrue(res.containsKey(j)); + + // assertTrue(res.containsKey(j)); + // because of non-overlap constraint + // assertTrue(res.containsKey(j) || res.containsKey(boxedJ)); + + map = res; + } + } + + // map.printStatistics(); + // System.out.println(map); + + System.out.println(); + System.out.println(String.format("PRIMITIVE: %10d (%.2f percent)", smallCount, + 100. * smallCount / (smallCount + bigCount))); + System.out.println(String.format("BIG_INTEGER: %10d (%.2f percent)", bigCount, + 100. * bigCount / (smallCount + bigCount))); + System.out.println(String.format("UNIQUE: %10d (%.2f percent)", map.size(), + 100. * map.size() / (smallCount + bigCount))); + System.out.println(); + } + + static final int populationCountPattern01(int v) { + int c = (v & 0x55555555) & (((v >> 1) & 0x55555555) ^ 0x55555555); + c = (c & 0x33333333) + ((c >> 2) & 0x33333333); + c = (c & 0x0F0F0F0F) + ((c >> 4) & 0x0F0F0F0F); + c = (c & 0x00FF00FF) + ((c >> 8) & 0x00FF00FF); + c = (c & 0x0000FFFF) + ((c >> 16) & 0x0000FFFF); + return c; + } + + @Test + public void testPopulationCountPattern01() { + assertEquals(2, populationCountPattern01(0b010001)); + assertEquals(3, populationCountPattern01(0b010101)); + assertEquals(2, populationCountPattern01(0b011001)); + assertEquals(2, populationCountPattern01(0b011101)); + } + + static final int populationCountPattern10(int v) { + int c = ((v & 0x55555555) ^ 0x55555555) & ((v >> 1) & 0x55555555); + c = (c & 0x33333333) + ((c >> 2) & 0x33333333); + c = (c & 0x0F0F0F0F) + ((c >> 4) & 0x0F0F0F0F); + c = (c & 0x00FF00FF) + ((c >> 8) & 0x00FF00FF); + c = (c & 0x0000FFFF) + ((c >> 16) & 0x0000FFFF); + return c; + } + + @Test + public void testPopulationCountPattern10() { + assertEquals(2, populationCountPattern10(0b100010)); + assertEquals(3, populationCountPattern10(0b101010)); + assertEquals(2, populationCountPattern10(0b100110)); + assertEquals(2, populationCountPattern10(0b101110)); + } + + static final int populationCountPattern11(int v) { + int c = (v & 0x55555555) & ((v >> 1) & 0x55555555); + c = (c & 0x33333333) + ((c >> 2) & 0x33333333); + c = (c & 0x0F0F0F0F) + ((c >> 4) & 0x0F0F0F0F); + c = (c & 0x00FF00FF) + ((c >> 8) & 0x00FF00FF); + c = (c & 0x0000FFFF) + ((c >> 16) & 0x0000FFFF); + return c; + } + + @Test + public void testPopulationCountPattern11() { + assertEquals(2, populationCountPattern11(0b110011)); + assertEquals(3, populationCountPattern11(0b111111)); + assertEquals(2, populationCountPattern11(0b110111)); + assertEquals(2, populationCountPattern11(0b111011)); + } + +} diff --git a/src/test/java/io/usethesource/capsule/BasicTrieMapTest.java b/capsule-veritas/src/test/java/io/usethesource/capsule/MapSmokeTest.java similarity index 68% rename from src/test/java/io/usethesource/capsule/BasicTrieMapTest.java rename to capsule-veritas/src/test/java/io/usethesource/capsule/MapSmokeTest.java index f1967e0..fe1a0c3 100644 --- a/src/test/java/io/usethesource/capsule/BasicTrieMapTest.java +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/MapSmokeTest.java @@ -7,27 +7,23 @@ */ package io.usethesource.capsule; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Random; +import io.usethesource.capsule.core.PersistentTrieMap; import org.junit.Test; -import io.usethesource.capsule.ImmutableMap; -import io.usethesource.capsule.TransientMap; -import io.usethesource.capsule.TrieMap_5Bits; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; -public class BasicTrieMapTest { +public class MapSmokeTest { /* * UTILS */ - @SuppressWarnings("rawtypes") - private static Class targetMapClass = TrieMap_5Bits.class; + private static Class targetMapClass = PersistentTrieMap.class; private static Method persistentMapOfEmpty; private static Method persistentMapOfKeyValuePairs; @@ -35,8 +31,7 @@ public class BasicTrieMapTest { private static Method transientMapOfEmpty; private static Method transientMapOfKeyValuePairs; - @SuppressWarnings("rawtypes") - public static Class getTargetMapClass() { + public static Class getTargetMapClass() { return targetMapClass; } @@ -45,45 +40,42 @@ public static Class getTargetMapClass() { persistentMapOfEmpty = targetMapClass.getMethod("of"); persistentMapOfKeyValuePairs = targetMapClass.getMethod("of", Object[].class); - transientMapOfEmpty = targetMapClass.getMethod("transientOf"); - transientMapOfKeyValuePairs = targetMapClass.getMethod("transientOf", Object[].class); + transientMapOfEmpty = targetMapClass.getMethod("of"); + transientMapOfKeyValuePairs = targetMapClass.getMethod("of", Object[].class); } catch (NoSuchMethodException | SecurityException e) { e.printStackTrace(); throw new RuntimeException(e); } } - @SuppressWarnings("unchecked") - public static final ImmutableMap mapOf() { + public static final Map.Immutable mapOf() { try { - return (ImmutableMap) persistentMapOfEmpty.invoke(null); + return (Map.Immutable) persistentMapOfEmpty.invoke(null); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { throw new RuntimeException(e); } } - @SuppressWarnings("unchecked") - public static final ImmutableMap mapOf(Object... keyValuePairs) { + public static final Map.Immutable mapOf(Object... keyValuePairs) { try { - return (ImmutableMap) persistentMapOfKeyValuePairs.invoke(null, (Object) keyValuePairs); + return (Map.Immutable) persistentMapOfKeyValuePairs + .invoke(null, (Object) keyValuePairs); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { throw new RuntimeException(e); } } - @SuppressWarnings("unchecked") - public static final TransientMap transientMapOf() { + public static final Map.Transient transientMapOf() { try { - return (TransientMap) transientMapOfEmpty.invoke(null); + return (Map.Transient) transientMapOfEmpty.invoke(null); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { throw new RuntimeException(e); } } - @SuppressWarnings("unchecked") - public static final TransientMap transientMapOf(Object... keyValuePairs) { + public static final Map.Transient transientMapOf(Object... keyValuePairs) { try { - return (TransientMap) transientMapOfKeyValuePairs.invoke(null, (Object) keyValuePairs); + return (Map.Transient) transientMapOfKeyValuePairs.invoke(null, (Object) keyValuePairs); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { e.printStackTrace(); throw new RuntimeException(e); @@ -100,10 +92,10 @@ public static final TransientMap transientMapOf(Object... keyValueP public void testPrintStatsSequential() { // int size = 128; - ImmutableMap map = (ImmutableMap) mapOf(); + Map.Immutable map = (Map.Immutable) mapOf(); for (int i = size; i > 0; i--) { - ImmutableMap res = map.__put(i, i); + Map.Immutable res = map.__put(i, i); assert res.containsKey(i); map = res; } @@ -115,14 +107,14 @@ public void testPrintStatsSequential() { public void testPrintStatsRandom() { // int size = 128; - ImmutableMap map = (ImmutableMap) mapOf(); + Map.Immutable map = (Map.Immutable) mapOf(); Random rand = new Random(13); for (int i = size; i > 0; i--) { final int j = rand.nextInt(); - ImmutableMap res = map.__put(j, j); + Map.Immutable res = map.__put(j, j); assert res.containsKey(j); map = res; } @@ -134,10 +126,10 @@ public void testPrintStatsRandom() { public void testCheckPrefixConstruction() { // int size = 128; - ImmutableMap map = (ImmutableMap) mapOf(); + Map.Immutable map = (Map.Immutable) mapOf(); - ImmutableMap res1 = map.__put(63, 63).__put(64, 64) - .__put(32768, 32768).__put(2147483647, 2147483647).__put(65536, 65536); + Map.Immutable res1 = map.__put(63, 63).__put(64, 64).__put(32768, 32768) + .__put(2147483647, 2147483647).__put(65536, 65536); assert res1.containsKey(63); assert res1.containsKey(64); @@ -145,8 +137,8 @@ public void testCheckPrefixConstruction() { assert res1.containsKey(65536); assert res1.containsKey(2147483647); - ImmutableMap res2 = map.__put(2147483647, 2147483647) - .__put(32768, 32768).__put(63, 63).__put(64, 64).__put(65536, 65536); + Map.Immutable res2 = map.__put(2147483647, 2147483647).__put(32768, 32768) + .__put(63, 63).__put(64, 64).__put(65536, 65536); assert res2.containsKey(63); assert res2.containsKey(64); @@ -159,30 +151,27 @@ public void testCheckPrefixConstruction() { getTargetMapClass().cast(map).printStatistics(); } - @SuppressWarnings({"rawtypes", "unchecked"}) @Test public void testCheckCompactionFromBeginUponDelete() { - ImmutableMap map = (ImmutableMap) mapOf(); + Map.Immutable map = (Map.Immutable) mapOf(); - ImmutableMap res1 = map.__put(1, 1).__put(2, 2); + Map.Immutable res1 = map.__put(1, 1).__put(2, 2); - ImmutableMap res2 = res1.__put(32769, 32769).__remove(2); + Map.Immutable res2 = res1.__put(32769, 32769).__remove(2); // what to test for? assert !res1.equals(res2); } - @SuppressWarnings({"rawtypes", "unchecked"}) @Test public void testCheckCompactionFromMiddleUponDelete() { - ImmutableMap map = (ImmutableMap) mapOf(); + Map.Immutable map = (Map.Immutable) mapOf(); - ImmutableMap res1 = - map.__put(1, 1).__put(2, 2).__put(65, 65).__put(66, 66); + Map.Immutable res1 = map.__put(1, 1).__put(2, 2).__put(65, 65).__put(66, 66); - ImmutableMap res2 = res1.__put(32769, 32769).__remove(66); + Map.Immutable res2 = res1.__put(32769, 32769).__remove(66); // what to test for? assert !res1.equals(res2); @@ -196,25 +185,24 @@ public static PureSeparateHashCodeInteger p(int value) { return new PureSeparateHashCodeInteger(value, value); } - @SuppressWarnings({"rawtypes", "unchecked"}) @Test public void testCheckCompactionFromBeginUponDelete_HashCollisionNode1() { - ImmutableMap map = mapOf(); + Map.Immutable map = mapOf(); - ImmutableMap res1 = map.__put(p(11, 1), p(11, 1)).__put(p(12, 1), p(12, 1)); + Map.Immutable res1 = map.__put(p(11, 1), p(11, 1)).__put(p(12, 1), p(12, 1)); assertTrue(res1.containsKey(p(11, 1))); assertTrue(res1.containsKey(p(12, 1))); - ImmutableMap res2 = res1.__remove(p(12, 1)); + Map.Immutable res2 = res1.__remove(p(12, 1)); assertTrue(res2.containsKey(p(11, 1))); assertEquals(mapOf(p(11, 1), p(11, 1)), res2); - ImmutableMap res3 = res1.__remove(p(11, 1)); + Map.Immutable res3 = res1.__remove(p(11, 1)); assertTrue(res3.containsKey(p(12, 1))); assertEquals(mapOf(p(12, 1), p(12, 1)), res3); - ImmutableMap resX = res1.__put(p(32769), p(32769)).__remove(p(12, 1)); + Map.Immutable resX = res1.__put(p(32769), p(32769)).__remove(p(12, 1)); assertTrue(resX.containsKey(p(11, 1))); assertTrue(resX.containsKey(p(32769))); @@ -222,53 +210,50 @@ public void testCheckCompactionFromBeginUponDelete_HashCollisionNode1() { assert !res1.equals(resX); } - @SuppressWarnings({"rawtypes", "unchecked"}) @Test public void testCheckCompactionFromBeginUponDelete_HashCollisionNode2() { - ImmutableMap map = mapOf(); + Map.Immutable map = mapOf(); - ImmutableMap res1 = map.__put(p(32769_1, 32769), p(32769_1, 32769)) - .__put(p(32769_2, 32769), p(32769_2, 32769)); + Map.Immutable res1 = + map.__put(p(32769_1, 32769), p(32769_1, 32769)).__put(p(32769_2, 32769), p(32769_2, 32769)); assertEquals(2, res1.size()); assertTrue(res1.containsKey(p(32769_1, 32769))); assertTrue(res1.containsKey(p(32769_2, 32769))); - ImmutableMap res2 = res1.__put(p(1, 1), p(1, 1)); + Map.Immutable res2 = res1.__put(p(1, 1), p(1, 1)); assertEquals(3, res2.size()); assertTrue(res2.containsKey(p(1, 1))); assertTrue(res2.containsKey(p(32769_1, 32769))); assertTrue(res2.containsKey(p(32769_2, 32769))); - ImmutableMap res3 = res2.__remove(p(32769_2, 32769)); + Map.Immutable res3 = res2.__remove(p(32769_2, 32769)); assertEquals(2, res3.size()); assertTrue(res3.containsKey(p(1, 1))); assertTrue(res3.containsKey(p(32769_1, 32769))); - ImmutableMap expected = - mapOf(p(1, 1), p(1, 1), p(32769_1, 32769), p(32769_1, 32769)); + Map.Immutable expected = mapOf(p(1, 1), p(1, 1), p(32769_1, 32769), p(32769_1, 32769)); assertEquals(expected, res3); } - @SuppressWarnings({"rawtypes", "unchecked"}) @Test public void testCheckCompactionFromBeginUponDelete_HashCollisionNode3() { - ImmutableMap map = mapOf(); + Map.Immutable map = mapOf(); - ImmutableMap res1 = map.__put(p(32769_1, 32769), p(32769_1, 32769)) - .__put(p(32769_2, 32769), p(32769_2, 32769)); + Map.Immutable res1 = + map.__put(p(32769_1, 32769), p(32769_1, 32769)).__put(p(32769_2, 32769), p(32769_2, 32769)); assertEquals(2, res1.size()); assertTrue(res1.containsKey(p(32769_1, 32769))); assertTrue(res1.containsKey(p(32769_2, 32769))); - ImmutableMap res2 = res1.__put(p(1, 1), p(1, 1)); + Map.Immutable res2 = res1.__put(p(1, 1), p(1, 1)); assertEquals(3, res2.size()); assertTrue(res2.containsKey(p(1, 1))); assertTrue(res2.containsKey(p(32769_1, 32769))); assertTrue(res2.containsKey(p(32769_2, 32769))); - ImmutableMap res3 = res2.__remove(p(1, 1)); + Map.Immutable res3 = res2.__remove(p(1, 1)); assertEquals(2, res3.size()); assertTrue(res3.containsKey(p(32769_1, 32769))); assertTrue(res3.containsKey(p(32769_2, 32769))); @@ -276,25 +261,24 @@ public void testCheckCompactionFromBeginUponDelete_HashCollisionNode3() { assertEquals(res1, res3); } - @SuppressWarnings({"rawtypes", "unchecked"}) @Test public void testCheckCompactionFromBeginUponDelete_HashCollisionNode4() { - ImmutableMap map = mapOf(); + Map.Immutable map = mapOf(); - ImmutableMap res1 = map.__put(p(32769_1, 32769), p(32769_1, 32769)) - .__put(p(32769_2, 32769), p(32769_2, 32769)); + Map.Immutable res1 = + map.__put(p(32769_1, 32769), p(32769_1, 32769)).__put(p(32769_2, 32769), p(32769_2, 32769)); assertEquals(2, res1.size()); assertTrue(res1.containsKey(p(32769_1, 32769))); assertTrue(res1.containsKey(p(32769_2, 32769))); - ImmutableMap res2 = res1.__put(p(5), p(5)); + Map.Immutable res2 = res1.__put(p(5), p(5)); assertEquals(3, res2.size()); assertTrue(res2.containsKey(p(5))); assertTrue(res2.containsKey(p(32769_1, 32769))); assertTrue(res2.containsKey(p(32769_2, 32769))); - ImmutableMap res3 = res2.__remove(p(5)); + Map.Immutable res3 = res2.__remove(p(5)); assertEquals(2, res3.size()); assertTrue(res3.containsKey(p(32769_1, 32769))); assertTrue(res3.containsKey(p(32769_2, 32769))); @@ -328,7 +312,7 @@ static byte recoverMask(int map, byte i_th) { } throw new RuntimeException("Called with invalid arguments."); // cnt1 != - // i_th + // i_th } // @Test @@ -376,15 +360,15 @@ static byte recoverMask(int map, byte i_th) { @Test public void testCreateSingletonWithFactoryMethod() { - ImmutableMap map = mapOf(63, 65); + Map.Immutable map = mapOf(63, 65); assertTrue(map.containsKey(63)); assertEquals(Integer.valueOf(65), map.get(63)); } @Test public void testRemoveFromSingleton() { - ImmutableMap map = mapOf(63, 65); - ImmutableMap res = map.__remove(63); + Map.Immutable map = mapOf(63, 65); + Map.Immutable res = map.__remove(63); assertTrue(res.isEmpty()); assertFalse(res.containsKey(63)); assertEquals(mapOf(), res); diff --git a/capsule-veritas/src/test/java/io/usethesource/capsule/OrderedTrieMapTest.java b/capsule-veritas/src/test/java/io/usethesource/capsule/OrderedTrieMapTest.java new file mode 100644 index 0000000..2cad814 --- /dev/null +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/OrderedTrieMapTest.java @@ -0,0 +1,122 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.util.Iterator; + +import io.usethesource.capsule.experimental.ordered.OrderedTrieMap; +import org.junit.Assert; +import org.junit.Test; + +import static java.lang.System.out; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +public class OrderedTrieMapTest { + + static OrderedTrieMap createBasicMap() { + return OrderedTrieMap.of().insert("5", 5).insert("7", 7).insert("-1", -1) + .insert("32", 32).insert("1500", 1500); + } + + static OrderedTrieMap createBiggerMap() { + return OrderedTrieMap.of().insert("5", 5).insert("7", 7).insert("-1", -1) + .insert("32", 32).insert("1500", 1500).insert("34934502", 34934502).insert("3344", 3344) + .insert("0", 0).insert("13", 13).insert("345", 345).insert("-15", -15).insert("33", 33) + .insert("32", 32); + } + + @Test + public void basicContainsKeyValue() { + OrderedTrieMap map = createBasicMap(); + + assertTrue(map.contains("5")); + assertTrue(map.containsValue(5)); + + assertTrue(map.contains("7")); + assertTrue(map.containsValue(7)); + + assertTrue(map.contains("-1")); + assertTrue(map.containsValue(-1)); + + assertTrue(map.contains("32")); + assertTrue(map.containsValue(32)); + + assertTrue(map.contains("1500")); + assertTrue(map.containsValue(1500)); + } + + @Test + public void basicOrderedKeyIterator() { + OrderedTrieMap map = createBasicMap(); + + Iterator it = map.orderedKeyIterator(); + + assertEquals("5", it.next()); + assertEquals("7", it.next()); + assertEquals("-1", it.next()); + assertEquals("32", it.next()); + assertEquals("1500", it.next()); + assertFalse(it.hasNext()); + } + + @Test + public void basicReverseOrderedKeyIterator() { + OrderedTrieMap map = createBasicMap(); + + Iterator it = map.reverseOrderedKeyIterator(); + + assertEquals("1500", it.next()); + assertEquals("32", it.next()); + assertEquals("-1", it.next()); + assertEquals("7", it.next()); + assertEquals("5", it.next()); + assertFalse(it.hasNext()); + } + + @Test + public void basicOrderedKeyIteratorAfterDeleteAndInsert() { + OrderedTrieMap map = createBasicMap().remove("-1").insert("-1", -1); + + Iterator it = map.orderedKeyIterator(); + + assertEquals("5", it.next()); + assertEquals("7", it.next()); + assertEquals("32", it.next()); + assertEquals("1500", it.next()); + assertEquals("-1", it.next()); + assertFalse(it.hasNext()); + } + + @Test + public void basicOrderedKeyIteratorAfterReplace() { + OrderedTrieMap map = createBasicMap().insert("-1", -1); + + Iterator it = map.orderedKeyIterator(); + + assertEquals("5", it.next()); + assertEquals("7", it.next()); + assertEquals("-1", it.next()); + assertEquals("32", it.next()); + assertEquals("1500", it.next()); + assertFalse(it.hasNext()); + } + + @Test + public void basicReplaceRetainsSize() { + Assert.assertEquals(createBasicMap().size(), createBasicMap().insert("-1", -1).size()); + } + + @Test + public void basicToString() { + OrderedTrieMap map = createBasicMap(); + out.println(map); + } + +} diff --git a/src/main/java/io/usethesource/capsule/Supplier.java b/capsule-veritas/src/test/java/io/usethesource/capsule/RuntimeCodeGenerationTest.java similarity index 72% rename from src/main/java/io/usethesource/capsule/Supplier.java rename to capsule-veritas/src/test/java/io/usethesource/capsule/RuntimeCodeGenerationTest.java index d2f817d..77085e8 100644 --- a/src/main/java/io/usethesource/capsule/Supplier.java +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/RuntimeCodeGenerationTest.java @@ -7,9 +7,8 @@ */ package io.usethesource.capsule; -@Deprecated -public interface Supplier { - - T get(); +import org.junit.runner.RunWith; +@RunWith(RuntimeCodeGenerationTestSuite.class) +public class RuntimeCodeGenerationTest { } diff --git a/capsule-veritas/src/test/java/io/usethesource/capsule/RuntimeCodeGenerationTestSuite.java b/capsule-veritas/src/test/java/io/usethesource/capsule/RuntimeCodeGenerationTestSuite.java new file mode 100644 index 0000000..aba5d24 --- /dev/null +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/RuntimeCodeGenerationTestSuite.java @@ -0,0 +1,218 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.net.URI; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; + +import io.usethesource.capsule.core.PersistentTrieSet; +import io.usethesource.capsule.experimental.lazy.TrieSet_5Bits_LazyHashCode; +import io.usethesource.capsule.experimental.memoized.TrieSet_5Bits_Memoized_LazyHashCode; +import io.usethesource.capsule.experimental.specialized.TrieSet_5Bits_Spec0To8; +import javax.tools.FileObject; +import javax.tools.ForwardingJavaFileManager; +import javax.tools.JavaCompiler; +import javax.tools.JavaFileManager; +import javax.tools.JavaFileObject; +import javax.tools.SimpleJavaFileObject; +import javax.tools.ToolProvider; +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.model.InitializationError; + +@RunWith(Suite.class) +public class RuntimeCodeGenerationTestSuite extends Suite { + + public RuntimeCodeGenerationTestSuite(Class setupClass) throws InitializationError { + super(setupClass, getClasses(setupClass)); + } + + private static Class[] getClasses(Class setupClass) { + final List> suiteClasses = new ArrayList>(); + + // @formatter:off + final List componentTypes = Arrays.asList(Integer.class); + final List setTypes = Arrays.asList( + PersistentTrieSet.class + , TrieSet_5Bits_Spec0To8.class + , TrieSet_5Bits_LazyHashCode.class + , TrieSet_5Bits_Memoized_LazyHashCode.class + ); + + final String javaClassNameTemplate = "io.usethesource.capsule.$CLASS_NAME$$COMPONENT_TYPE$SetPropertiesTest"; + final String javaSourceCodeTemplate = + "package io.usethesource.capsule;\n" + + "import $QUALIFIED_CLASS_NAME$;\n" + + "@org.junit.runner.RunWith(com.pholser.junit.quickcheck.runner.JUnitQuickcheck.class)\n" + + + "public class $CLASS_NAME$$COMPONENT_TYPE$SetPropertiesTest extends AbstractSetProperties<$COMPONENT_TYPE$, $CLASS_NAME$<$COMPONENT_TYPE$>> {\n" + + + " public $CLASS_NAME$$COMPONENT_TYPE$SetPropertiesTest() {\n" + + " super($CLASS_NAME$.class);\n" + + " }\n" + + "}\n"; + // @formatter:on + + setTypes.stream().flatMap(setKlass -> componentTypes.stream().map(componentKlass -> { + try { + // @formatter:off + final String className = javaClassNameTemplate + .replace("$COMPONENT_TYPE$", componentKlass.getSimpleName()) + .replace("$QUALIFIED_CLASS_NAME$", setKlass.getName()) + .replace("$CLASS_NAME$", setKlass.getSimpleName()); + + final String sourceCode = javaSourceCodeTemplate + .replace("$COMPONENT_TYPE$", componentKlass.getSimpleName()) + .replace("$QUALIFIED_CLASS_NAME$", setKlass.getName()) + .replace("$CLASS_NAME$", setKlass.getSimpleName()); + // @formatter:on + + Class aClass = RuntimeJavaCompiler.compile(className, sourceCode); + return aClass; + } catch (Throwable throwable) { + throw new RuntimeException(throwable); + } + })).forEach(suiteClasses::add); + + return suiteClasses.toArray(new Class[0]); + } + + private String subsituteComponentType(String template, Class klass) { + return template.replace("$COMPONENT_TYPE$", klass.getSimpleName()); + } + + private String subsituteSetType(String template, Class klass) { + // @formatter:off + return template + .replace("$QUALIFIED_CLASS_NAME$", klass.getName()) + .replace("$CLASS_NAME$", klass.getSimpleName()); + // @formatter:on + } + + private static class RuntimeJavaCompiler { + + static final JavaCompiler JAVA_COMPILER = ToolProvider.getSystemJavaCompiler(); + + public static Class compile(String className, String sourceCode) throws Exception { + // re-use current class path for compilation + final String classPath = System.getProperty("java.class.path"); + final Iterable options = Arrays.asList("-classpath", classPath); + + JavaFileObject src = new JavaSourceFromString(className, sourceCode); + + CustomClassLoader classLoader = new CustomClassLoader(ClassLoader.getSystemClassLoader()); + CustomJavaFileManager fileManager = new CustomJavaFileManager( + JAVA_COMPILER.getStandardFileManager(null, null, null), classLoader); + + JavaCompiler.CompilationTask task = + JAVA_COMPILER.getTask(null, fileManager, null, options, null, Collections.singleton(src)); + boolean result = task.call(); + + return classLoader.loadClass(className); + } + } + + private static class JavaSourceFromString extends SimpleJavaFileObject { + + private final String sourceCode; + + private static final URI toURI(String className) { + return URI.create("string:///" + className.replace('.', '/') + Kind.SOURCE.extension); + } + + public JavaSourceFromString(String className, String sourceCode) throws Exception { + super(toURI(className), Kind.SOURCE); + this.sourceCode = sourceCode; + } + + @Override + public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException { + return sourceCode; + } + } + + private static class ByteCodeFromString extends SimpleJavaFileObject { + + private final ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + + private static final URI toURI(String className) throws Exception { + return new URI(className); + } + + public ByteCodeFromString(String className) throws Exception { + super(toURI(className), Kind.CLASS); + } + + @Override + public OutputStream openOutputStream() throws IOException { + return outputStream; // already opened at construction + } + + public byte[] getByteCode() { + return outputStream.toByteArray(); + } + } + + private static class CustomClassLoader extends ClassLoader { + + private final java.util.Map classes = new HashMap<>(); + + public CustomClassLoader(ClassLoader parentClassLoader) { + super(parentClassLoader); + } + + public void setByteCode(ByteCodeFromString javaFile) { + classes.put(javaFile.getName(), javaFile); + } + + @Override + protected Class findClass(String name) throws ClassNotFoundException { + ByteCodeFromString javaFile = classes.get(name); + if (javaFile != null) { + byte[] byteCode = javaFile.getByteCode(); + return defineClass(name, byteCode, 0, byteCode.length); + } + return super.findClass(name); + } + } + + private static class CustomJavaFileManager extends ForwardingJavaFileManager { + + private final CustomClassLoader classLoader; + + protected CustomJavaFileManager(JavaFileManager fileManager, CustomClassLoader classLoader) { + super(fileManager); + this.classLoader = classLoader; + } + + @Override + public JavaFileObject getJavaFileForOutput(JavaFileManager.Location location, String className, + JavaFileObject.Kind kind, FileObject sibling) { + try { + ByteCodeFromString javaFile = new ByteCodeFromString(className); + classLoader.setByteCode(javaFile); + return javaFile; + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + @Override + public ClassLoader getClassLoader(JavaFileManager.Location location) { + return classLoader; + } + } + +} diff --git a/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapPropertiesOfHchampTest.java b/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapPropertiesOfHchampTest.java new file mode 100644 index 0000000..27c617f --- /dev/null +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapPropertiesOfHchampTest.java @@ -0,0 +1,22 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; +import io.usethesource.capsule.core.PersistentTrieSetMultimap; +import org.junit.runner.RunWith; + +@RunWith(JUnitQuickcheck.class) +public class SetMultimapPropertiesOfHchampTest extends + AbstractSetMultimapProperties> { + + public SetMultimapPropertiesOfHchampTest() { + super(PersistentTrieSetMultimap.class); + } + +} diff --git a/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapPropertiesOfHhamtTest.java b/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapPropertiesOfHhamtTest.java new file mode 100644 index 0000000..984af14 --- /dev/null +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapPropertiesOfHhamtTest.java @@ -0,0 +1,22 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT; +import org.junit.runner.RunWith; + +@RunWith(JUnitQuickcheck.class) +public class SetMultimapPropertiesOfHhamtTest extends + AbstractSetMultimapProperties> { + + public SetMultimapPropertiesOfHhamtTest() { + super(TrieSetMultimap_HHAMT.class); + } + +} diff --git a/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapPropertiesOfPersistentBidirectionalTrieSetMultimapTest.java b/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapPropertiesOfPersistentBidirectionalTrieSetMultimapTest.java new file mode 100644 index 0000000..7c9642f --- /dev/null +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapPropertiesOfPersistentBidirectionalTrieSetMultimapTest.java @@ -0,0 +1,22 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; +import io.usethesource.capsule.core.PersistentBidirectionalTrieSetMultimap; +import org.junit.runner.RunWith; + +@RunWith(JUnitQuickcheck.class) +public class SetMultimapPropertiesOfPersistentBidirectionalTrieSetMultimapTest extends + AbstractBinaryRelationProperties> { + + public SetMultimapPropertiesOfPersistentBidirectionalTrieSetMultimapTest() { + super(PersistentBidirectionalTrieSetMultimap.class); + } + +} diff --git a/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapPropertiesTest.java b/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapPropertiesTest.java new file mode 100644 index 0000000..d79c7f8 --- /dev/null +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapPropertiesTest.java @@ -0,0 +1,21 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; +import org.junit.runner.RunWith; + +@RunWith(JUnitQuickcheck.class) +public class SetMultimapPropertiesTest extends + AbstractSetMultimapProperties> { + + public SetMultimapPropertiesTest() { + super(SetMultimap.Immutable.class); + } + +} diff --git a/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapSmokeTest.java b/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapSmokeTest.java new file mode 100644 index 0000000..bb3a439 --- /dev/null +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/SetMultimapSmokeTest.java @@ -0,0 +1,75 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import java.util.Collection; + +import io.usethesource.capsule.experimental.multimap.TrieSetMultimap_HHAMT_Specialized_Path_Interlinked; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +public class SetMultimapSmokeTest { + + final static int size = 64; + + @Test + public void testInsertTwoTuplesThatShareSameKey() { + SetMultimap.Immutable map = + TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.of().__insert(1, "x") + .__insert(1, "y"); + + assertEquals(2, map.size()); + assertTrue(map.containsKey(1)); + } + + @Test + public void testInsertTwoTuplesWithOneRemoveThatShareSameKeyX() { + SetMultimap.Immutable map = TrieSetMultimap_HHAMT_Specialized_Path_Interlinked + .of().__insert(1, "x").__insert(1, "y").__remove(1, "x"); + + assertEquals(1, map.size()); + assertTrue(map.containsKey(1)); + } + + @Test + public void testInsertTwoTuplesWithOneRemoveThatShareSameKeyY() { + SetMultimap.Immutable map = TrieSetMultimap_HHAMT_Specialized_Path_Interlinked + .of().__insert(1, "x").__insert(1, "y").__remove(1, "y"); + + assertEquals(1, map.size()); + assertTrue(map.containsKey(1)); + } + + @Test + public void testInsertTwoTuplesWithOneRemoveThatShareSameKeyXY() { + SetMultimap.Immutable map = + TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.of().__insert(1, "x") + .__insert(1, "y") + .__remove(1, "x").__remove(1, "y"); + + assertEquals(0, map.size()); + assertFalse(map.containsKey(1)); + } + + @Test + public void testInsertTwoTuplesThatShareSameKey_Iterate() { + SetMultimap.Immutable map = + TrieSetMultimap_HHAMT_Specialized_Path_Interlinked.of().__insert(1, "x") + .__insert(1, "y"); + + Collection values = map.values(); + + assertEquals(2, values.size()); + assertTrue(values.contains("x")); + assertTrue(values.contains("y")); + } + +} diff --git a/capsule-veritas/src/test/java/io/usethesource/capsule/SetPropertiesTest.java b/capsule-veritas/src/test/java/io/usethesource/capsule/SetPropertiesTest.java new file mode 100644 index 0000000..da7d8e5 --- /dev/null +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/SetPropertiesTest.java @@ -0,0 +1,44 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; +import io.usethesource.capsule.core.PersistentTrieSet; +import org.junit.Ignore; +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +/** + * Static aggregation of set test. Superseeded by {@link RuntimeCodeGenerationTest}. + */ +@Deprecated +@Ignore +@RunWith(Suite.class) +@Suite.SuiteClasses({SetPropertiesTest.IntegerSetPropertiesTest.class, + SetPropertiesTest.StringSetPropertiesTest.class}) +public class SetPropertiesTest { + + @RunWith(JUnitQuickcheck.class) + public static class IntegerSetPropertiesTest + extends AbstractSetProperties> { + + public IntegerSetPropertiesTest() { + super(PersistentTrieSet.class); + } + } + + @RunWith(JUnitQuickcheck.class) + public static class StringSetPropertiesTest + extends AbstractSetProperties> { + + public StringSetPropertiesTest() { + super(PersistentTrieSet.class); + } + } + +} diff --git a/src/test/java/io/usethesource/capsule/BasicTrieSetTest.java b/capsule-veritas/src/test/java/io/usethesource/capsule/SetSmokeTest.java similarity index 70% rename from src/test/java/io/usethesource/capsule/BasicTrieSetTest.java rename to capsule-veritas/src/test/java/io/usethesource/capsule/SetSmokeTest.java index 489ba71..d37d046 100644 --- a/src/test/java/io/usethesource/capsule/BasicTrieSetTest.java +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/SetSmokeTest.java @@ -7,9 +7,6 @@ */ package io.usethesource.capsule; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - import java.util.Collections; import java.util.HashSet; import java.util.LinkedHashMap; @@ -17,15 +14,17 @@ import java.util.Map.Entry; import java.util.Set; +import io.usethesource.capsule.core.PersistentTrieSet; import org.junit.BeforeClass; import org.junit.Test; -import io.usethesource.capsule.ImmutableSet; -import io.usethesource.capsule.TrieSet_5Bits; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; -public class BasicTrieSetTest { +public class SetSmokeTest { private class DummyValue { + public final int value; public final int hashCode; @@ -67,7 +66,8 @@ public String toString() { } @BeforeClass - public static void setUpBeforeClass() throws Exception {} + public static void setUpBeforeClass() throws Exception { + } @Test public void testNodeValNode() { @@ -82,7 +82,7 @@ public void testNodeValNode() { input.put(7, 7); input.put(8, 7); - ImmutableSet set = TrieSet_5Bits.of(); + io.usethesource.capsule.Set.Immutable set = PersistentTrieSet.of(); for (Entry entry : input.entrySet()) { set = set.__insert(new DummyValue(entry.getKey(), entry.getValue())); @@ -105,7 +105,7 @@ public void testValNodeVal() { input.put(6, 5); input.put(7, 7); - ImmutableSet set = TrieSet_5Bits.of(); + io.usethesource.capsule.Set.Immutable set = PersistentTrieSet.of(); for (Entry entry : input.entrySet()) { set = set.__insert(new DummyValue(entry.getKey(), entry.getValue())); @@ -128,7 +128,7 @@ public void testIteration() { input.put(6, 5); input.put(7, 7); - ImmutableSet set = TrieSet_5Bits.of(); + io.usethesource.capsule.Set.Immutable set = PersistentTrieSet.of(); for (Entry entry : input.entrySet()) { set = set.__insert(new DummyValue(entry.getKey(), entry.getValue())); @@ -206,7 +206,8 @@ public void IterateWithLastBitsDifferent() { todo.add(hash_n2147483648_obj1); todo.add(hash_p1073741824_obj2); - ImmutableSet xs = TrieSet_5Bits.of(hash_n2147483648_obj1, hash_p1073741824_obj2); + io.usethesource.capsule.Set.Immutable xs = PersistentTrieSet + .of(hash_n2147483648_obj1, hash_p1073741824_obj2); for (DummyValue x : xs) { todo.remove(x); @@ -220,8 +221,10 @@ public void TwoCollisionsEquals() { DummyValue hash98304_obj1 = new DummyValue(1, 98304); DummyValue hash98304_obj2 = new DummyValue(2, 98304); - ImmutableSet xs = TrieSet_5Bits.of(hash98304_obj1, hash98304_obj2); - ImmutableSet ys = TrieSet_5Bits.of(hash98304_obj2, hash98304_obj1); + io.usethesource.capsule.Set.Immutable xs = PersistentTrieSet + .of(hash98304_obj1, hash98304_obj2); + io.usethesource.capsule.Set.Immutable ys = PersistentTrieSet + .of(hash98304_obj2, hash98304_obj1); assertEquals(xs, ys); } @@ -232,8 +235,10 @@ public void ThreeCollisionsEquals() { DummyValue hash98304_obj2 = new DummyValue(2, 98304); DummyValue hash98304_obj3 = new DummyValue(3, 98304); - ImmutableSet xs = TrieSet_5Bits.of(hash98304_obj1, hash98304_obj2, hash98304_obj3); - ImmutableSet ys = TrieSet_5Bits.of(hash98304_obj3, hash98304_obj2, hash98304_obj1); + io.usethesource.capsule.Set.Immutable xs = PersistentTrieSet + .of(hash98304_obj1, hash98304_obj2, hash98304_obj3); + io.usethesource.capsule.Set.Immutable ys = PersistentTrieSet + .of(hash98304_obj3, hash98304_obj2, hash98304_obj1); assertEquals(xs, ys); } @@ -243,9 +248,9 @@ public void RemovalFromCollisonNodeEqualsSingelton() { DummyValue hash98304_obj1 = new DummyValue(1, 98304); DummyValue hash98304_obj2 = new DummyValue(2, 98304); - ImmutableSet xs = TrieSet_5Bits.of(hash98304_obj1); - ImmutableSet ys = - TrieSet_5Bits.of(hash98304_obj1, hash98304_obj2).__remove(hash98304_obj2); + io.usethesource.capsule.Set.Immutable xs = PersistentTrieSet.of(hash98304_obj1); + io.usethesource.capsule.Set.Immutable ys = + PersistentTrieSet.of(hash98304_obj1, hash98304_obj2).__remove(hash98304_obj2); assertEquals(xs, ys); } @@ -259,7 +264,8 @@ public void CollisionIterate() { todo.add(hash98304_obj1); todo.add(hash98304_obj2); - ImmutableSet xs = TrieSet_5Bits.of(hash98304_obj1, hash98304_obj2); + io.usethesource.capsule.Set.Immutable xs = PersistentTrieSet + .of(hash98304_obj1, hash98304_obj2); for (DummyValue x : xs) { todo.remove(x); @@ -275,9 +281,10 @@ public void CollisionWithMergeInlineAbove1() { DummyValue hash268435456_obj3 = new DummyValue(3, 268435456); - ImmutableSet xs = TrieSet_5Bits + io.usethesource.capsule.Set.Immutable xs = PersistentTrieSet .of(hash98304_obj1, hash98304_obj2, hash268435456_obj3).__remove(hash268435456_obj3); - ImmutableSet ys = TrieSet_5Bits.of(hash98304_obj1, hash98304_obj2); + io.usethesource.capsule.Set.Immutable ys = PersistentTrieSet + .of(hash98304_obj1, hash98304_obj2); assertEquals(xs, ys); } @@ -289,9 +296,11 @@ public void CollisionWithMergeInlineAbove1_2() { DummyValue hash268435456_obj3 = new DummyValue(3, 268435456); - ImmutableSet xs = - TrieSet_5Bits.of(hash8_obj1, hash8_obj2, hash268435456_obj3).__remove(hash268435456_obj3); - ImmutableSet ys = TrieSet_5Bits.of(hash8_obj1, hash8_obj2); + io.usethesource.capsule.Set.Immutable xs = + PersistentTrieSet.of(hash8_obj1, hash8_obj2, hash268435456_obj3) + .__remove(hash268435456_obj3); + io.usethesource.capsule.Set.Immutable ys = PersistentTrieSet + .of(hash8_obj1, hash8_obj2); assertEquals(xs, ys); } @@ -303,9 +312,10 @@ public void CollisionWithMergeInlineAbove2() { DummyValue hash268435456_obj3 = new DummyValue(3, 268435456); - ImmutableSet xs = TrieSet_5Bits + io.usethesource.capsule.Set.Immutable xs = PersistentTrieSet .of(hash98304_obj1, hash268435456_obj3, hash98304_obj2).__remove(hash268435456_obj3); - ImmutableSet ys = TrieSet_5Bits.of(hash98304_obj1, hash98304_obj2); + io.usethesource.capsule.Set.Immutable ys = PersistentTrieSet + .of(hash98304_obj1, hash98304_obj2); assertEquals(xs, ys); } @@ -317,9 +327,11 @@ public void CollisionWithMergeInlineAbove2_2() { DummyValue hash268435456_obj3 = new DummyValue(3, 268435456); - ImmutableSet xs = - TrieSet_5Bits.of(hash8_obj1, hash268435456_obj3, hash8_obj2).__remove(hash268435456_obj3); - ImmutableSet ys = TrieSet_5Bits.of(hash8_obj1, hash8_obj2); + io.usethesource.capsule.Set.Immutable xs = + PersistentTrieSet.of(hash8_obj1, hash268435456_obj3, hash8_obj2) + .__remove(hash268435456_obj3); + io.usethesource.capsule.Set.Immutable ys = PersistentTrieSet + .of(hash8_obj1, hash8_obj2); assertEquals(xs, ys); } @@ -331,9 +343,10 @@ public void CollisionWithMergeInlineAbove1RemoveOneCollisonNode() { DummyValue hash268435456_obj3 = new DummyValue(3, 268435456); - ImmutableSet xs = TrieSet_5Bits + io.usethesource.capsule.Set.Immutable xs = PersistentTrieSet .of(hash98304_obj1, hash98304_obj2, hash268435456_obj3).__remove(hash98304_obj2); - ImmutableSet ys = TrieSet_5Bits.of(hash98304_obj1, hash268435456_obj3); + io.usethesource.capsule.Set.Immutable ys = PersistentTrieSet + .of(hash98304_obj1, hash268435456_obj3); assertEquals(xs, ys); } @@ -345,9 +358,10 @@ public void CollisionWithMergeInlineAbove2RemoveOneCollisonNode() { DummyValue hash268435456_obj3 = new DummyValue(3, 268435456); - ImmutableSet xs = TrieSet_5Bits + io.usethesource.capsule.Set.Immutable xs = PersistentTrieSet .of(hash98304_obj1, hash268435456_obj3, hash98304_obj2).__remove(hash98304_obj2); - ImmutableSet ys = TrieSet_5Bits.of(hash98304_obj1, hash268435456_obj3); + io.usethesource.capsule.Set.Immutable ys = PersistentTrieSet + .of(hash98304_obj1, hash268435456_obj3); assertEquals(xs, ys); } @@ -359,9 +373,10 @@ public void CollisionWithMergeInlineBelow1() { DummyValue hash8_obj3 = new DummyValue(3, 8); - ImmutableSet xs = - TrieSet_5Bits.of(hash98304_obj1, hash98304_obj2, hash8_obj3).__remove(hash8_obj3); - ImmutableSet ys = TrieSet_5Bits.of(hash98304_obj1, hash98304_obj2); + io.usethesource.capsule.Set.Immutable xs = + PersistentTrieSet.of(hash98304_obj1, hash98304_obj2, hash8_obj3).__remove(hash8_obj3); + io.usethesource.capsule.Set.Immutable ys = PersistentTrieSet + .of(hash98304_obj1, hash98304_obj2); assertEquals(xs, ys); } @@ -373,9 +388,10 @@ public void CollisionWithMergeInlineBelow2() { DummyValue hash8_obj3 = new DummyValue(3, 8); - ImmutableSet xs = - TrieSet_5Bits.of(hash98304_obj1, hash8_obj3, hash98304_obj2).__remove(hash8_obj3); - ImmutableSet ys = TrieSet_5Bits.of(hash98304_obj1, hash98304_obj2); + io.usethesource.capsule.Set.Immutable xs = + PersistentTrieSet.of(hash98304_obj1, hash8_obj3, hash98304_obj2).__remove(hash8_obj3); + io.usethesource.capsule.Set.Immutable ys = PersistentTrieSet + .of(hash98304_obj1, hash98304_obj2); assertEquals(xs, ys); } @@ -387,9 +403,10 @@ public void CollisionWithMergeInlineBelowRemoveOneCollisonNode1() { DummyValue hash8_obj3 = new DummyValue(3, 8); - ImmutableSet xs = - TrieSet_5Bits.of(hash98304_obj1, hash98304_obj2, hash8_obj3).__remove(hash98304_obj2); - ImmutableSet ys = TrieSet_5Bits.of(hash98304_obj1, hash8_obj3); + io.usethesource.capsule.Set.Immutable xs = + PersistentTrieSet.of(hash98304_obj1, hash98304_obj2, hash8_obj3).__remove(hash98304_obj2); + io.usethesource.capsule.Set.Immutable ys = PersistentTrieSet + .of(hash98304_obj1, hash8_obj3); assertEquals(xs, ys); } @@ -401,9 +418,10 @@ public void CollisionWithMergeInlineBelowRemoveOneCollisonNode2() { DummyValue hash8_obj3 = new DummyValue(3, 8); - ImmutableSet xs = - TrieSet_5Bits.of(hash98304_obj1, hash8_obj3, hash98304_obj2).__remove(hash98304_obj2); - ImmutableSet ys = TrieSet_5Bits.of(hash98304_obj1, hash8_obj3); + io.usethesource.capsule.Set.Immutable xs = + PersistentTrieSet.of(hash98304_obj1, hash8_obj3, hash98304_obj2).__remove(hash98304_obj2); + io.usethesource.capsule.Set.Immutable ys = PersistentTrieSet + .of(hash98304_obj1, hash8_obj3); assertEquals(xs, ys); } diff --git a/capsule-veritas/src/test/java/io/usethesource/capsule/SetToLegacySetPropertiesTest.java b/capsule-veritas/src/test/java/io/usethesource/capsule/SetToLegacySetPropertiesTest.java new file mode 100644 index 0000000..8d03f52 --- /dev/null +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/SetToLegacySetPropertiesTest.java @@ -0,0 +1,40 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; +import io.usethesource.capsule.core.converter.SetToLegacySetConverter; +import org.junit.Ignore; +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +@Ignore("Semantic difference in equality is not yet resolved.") +@RunWith(Suite.class) +@Suite.SuiteClasses({SetToLegacySetPropertiesTest.IntegerSetPropertiesTest.class, + SetToLegacySetPropertiesTest.StringSetPropertiesTest.class}) +public class SetToLegacySetPropertiesTest { + + @RunWith(JUnitQuickcheck.class) + public static class IntegerSetPropertiesTest + extends AbstractSetProperties> { + + public IntegerSetPropertiesTest() { + super(SetToLegacySetConverter.class); + } + } + + @RunWith(JUnitQuickcheck.class) + public static class StringSetPropertiesTest + extends AbstractSetProperties> { + + public StringSetPropertiesTest() { + super(SetToLegacySetConverter.class); + } + } + +} diff --git a/capsule-veritas/src/test/java/io/usethesource/capsule/TernaryRelationTest.java b/capsule-veritas/src/test/java/io/usethesource/capsule/TernaryRelationTest.java new file mode 100644 index 0000000..76d4865 --- /dev/null +++ b/capsule-veritas/src/test/java/io/usethesource/capsule/TernaryRelationTest.java @@ -0,0 +1,22 @@ +/** + * Copyright (c) Michael Steindorfer and Contributors. + * All rights reserved. + * + * This file is licensed under the BSD 2-Clause License, which accompanies this project + * and is available under https://opensource.org/licenses/BSD-2-Clause. + */ +package io.usethesource.capsule; + +import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; +import io.usethesource.capsule.api.Triple; +import io.usethesource.capsule.experimental.relation.TernaryTrieSetMultimap; +import org.junit.runner.RunWith; + +@RunWith(JUnitQuickcheck.class) +public class TernaryRelationTest extends AbstractSetProperties, TernaryTrieSetMultimap>> { + + public TernaryRelationTest() { + super(TernaryTrieSetMultimap.class); + } + +} diff --git a/capsule.iml b/capsule.iml new file mode 100644 index 0000000..120030a --- /dev/null +++ b/capsule.iml @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/pom.xml b/pom.xml index e43d1d4..29cefe1 100644 --- a/pom.xml +++ b/pom.xml @@ -1,96 +1,145 @@ - - 4.0.0 + + + 4.0.0 - io.usethesource - capsule - 0.3.0-SNAPSHOT - jar + io.usethesource + capsule-pom-parent + 0.3.0.HETEROGENEOUS-SNAPSHOT + pom - - scm:git:https://github.com/usethesource/capsule.git - HEAD - + + scm:git:https://github.com/usethesource/capsule.git + HEAD + - - - - usethesource-releases - http://nexus.usethesource.io/content/repositories/releases/ - - - usethesource-snapshots - http://nexus.usethesource.io/content/repositories/snapshots/ - - + + capsule-core + capsule-experimental + capsule-veritas + - - - - usethesource - http://nexus.usethesource.io/content/repositories/public/ - - + + + + usethesource-releases + http://nexus.usethesource.io/content/repositories/releases/ + + + usethesource-snapshots + http://nexus.usethesource.io/content/repositories/snapshots/ + + - - UTF-8 - 1.8 - 1.8 - + + + + usethesource + http://nexus.usethesource.io/content/repositories/public/ + + - - - - org.apache.maven.plugins - maven-source-plugin - 2.4 - - - attach-sources - - jar - - - - - - org.apache.maven.plugins - maven-release-plugin - 2.5.3 - - - com.mycila - license-maven-plugin - 3.0 - -
${basedir}/LICENSE.header-template
- - SLASHSTAR_STYLE - - - src/** - - - - - - - - - check - - - - - - + + UTF-8 + 1.8 + 1.8 + ${basedir} + - - - junit - junit - 4.11 - test - - + + + + org.apache.maven.plugins + maven-source-plugin + 2.4 + + + attach-sources + + jar + + + + + + org.apache.maven.plugins + maven-release-plugin + 2.5.3 + - + + + + com.mycila + license-maven-plugin + 3.0 + +
${topleveldir}/LICENSE.header-template
+ + SLASHSTAR_STYLE + + + src/** + + + + + + + + + check + + + + + + + + + + junit + junit + 4.12 + test + + + + + + jdk9 + + false + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.5.1 + + + 1.9 + 1.9 + true + ${JAVA_HOME}/bin/javac + true + true + true + + + -XaddExports:java.base/jdk.internal.vm.annotation=ALL-UNNAMED + + + + + + + + \ No newline at end of file diff --git a/src/main/java/io/usethesource/capsule/DefaultTrieMap.java b/src/main/java/io/usethesource/capsule/DefaultTrieMap.java deleted file mode 100644 index b644c45..0000000 --- a/src/main/java/io/usethesource/capsule/DefaultTrieMap.java +++ /dev/null @@ -1,79 +0,0 @@ -/** - * Copyright (c) Michael Steindorfer and Contributors. - * All rights reserved. - * - * This file is licensed under the BSD 2-Clause License, which accompanies this project - * and is available under https://opensource.org/licenses/BSD-2-Clause. - */ -package io.usethesource.capsule; - -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; - -public class DefaultTrieMap { - - @SuppressWarnings("rawtypes") - private static Class target = TrieMap_5Bits.class; - - private static Method persistentMapOfEmpty; - private static Method persistentMapOfKeyValuePairs; - - private static Method transientMapOfEmpty; - private static Method transientMapOfKeyValuePairs; - - @SuppressWarnings("rawtypes") - public static Class getTargetClass() { - return target; - } - - static { - try { - persistentMapOfEmpty = target.getMethod("of"); - persistentMapOfKeyValuePairs = target.getMethod("of", Object[].class); - - transientMapOfEmpty = target.getMethod("transientOf"); - transientMapOfKeyValuePairs = target.getMethod("transientOf", Object[].class); - } catch (NoSuchMethodException | SecurityException e) { - e.printStackTrace(); - throw new RuntimeException(e); - } - } - - @SuppressWarnings("unchecked") - public static final ImmutableMap of() { - try { - return (ImmutableMap) persistentMapOfEmpty.invoke(null); - } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { - throw new RuntimeException(e); - } - } - - @SuppressWarnings("unchecked") - public static final ImmutableMap of(Object... keyValuePairs) { - try { - return (ImmutableMap) persistentMapOfKeyValuePairs.invoke(null, (Object) keyValuePairs); - } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { - throw new RuntimeException(e); - } - } - - @SuppressWarnings("unchecked") - public static final TransientMap transientOf() { - try { - return (TransientMap) transientMapOfEmpty.invoke(null); - } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { - throw new RuntimeException(e); - } - } - - @SuppressWarnings("unchecked") - public static final TransientMap transientOf(Object... keyValuePairs) { - try { - return (TransientMap) transientMapOfKeyValuePairs.invoke(null, (Object) keyValuePairs); - } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { - e.printStackTrace(); - throw new RuntimeException(e); - } - } - -} diff --git a/src/main/java/io/usethesource/capsule/DefaultTrieSet.java b/src/main/java/io/usethesource/capsule/DefaultTrieSet.java deleted file mode 100644 index 0183275..0000000 --- a/src/main/java/io/usethesource/capsule/DefaultTrieSet.java +++ /dev/null @@ -1,78 +0,0 @@ -/** - * Copyright (c) Michael Steindorfer and Contributors. - * All rights reserved. - * - * This file is licensed under the BSD 2-Clause License, which accompanies this project - * and is available under https://opensource.org/licenses/BSD-2-Clause. - */ -package io.usethesource.capsule; - -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; - -public class DefaultTrieSet { - - @SuppressWarnings("rawtypes") - private static Class target = TrieSet_5Bits.class; - - private static Method persistentSetOfEmpty; - private static Method persistentSetOfKeyValuePairs; - - private static Method transientSetOfEmpty; - private static Method transientSetOfKeyValuePairs; - - @SuppressWarnings("rawtypes") - public static Class getTargetClass() { - return target; - } - - static { - try { - persistentSetOfEmpty = target.getMethod("of"); - persistentSetOfKeyValuePairs = target.getMethod("of", Object[].class); - - transientSetOfEmpty = target.getMethod("transientOf"); - transientSetOfKeyValuePairs = target.getMethod("transientOf", Object[].class); - } catch (NoSuchMethodException | SecurityException e) { - e.printStackTrace(); - throw new RuntimeException(e); - } - } - - @SuppressWarnings("unchecked") - public static final ImmutableSet of() { - try { - return (ImmutableSet) persistentSetOfEmpty.invoke(null); - } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { - throw new RuntimeException(e); - } - } - - @SuppressWarnings("unchecked") - public static final ImmutableSet of(K... keys) { - try { - return (ImmutableSet) persistentSetOfKeyValuePairs.invoke(null, (Object) keys); - } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { - throw new RuntimeException(e); - } - } - - @SuppressWarnings("unchecked") - public static final TransientSet transientOf() { - try { - return (TransientSet) transientSetOfEmpty.invoke(null); - } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { - throw new RuntimeException(e); - } - } - - @SuppressWarnings("unchecked") - public static final TransientSet transientOf(K... keys) { - try { - return (TransientSet) transientSetOfKeyValuePairs.invoke(null, (Object) keys); - } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { - throw new RuntimeException(e); - } - } - -} diff --git a/src/main/java/io/usethesource/capsule/ImmutableMap.java b/src/main/java/io/usethesource/capsule/ImmutableMap.java deleted file mode 100644 index d709e16..0000000 --- a/src/main/java/io/usethesource/capsule/ImmutableMap.java +++ /dev/null @@ -1,54 +0,0 @@ -/** - * Copyright (c) Michael Steindorfer and Contributors. - * All rights reserved. - * - * This file is licensed under the BSD 2-Clause License, which accompanies this project - * and is available under https://opensource.org/licenses/BSD-2-Clause. - */ -package io.usethesource.capsule; - -import java.util.Comparator; -import java.util.Iterator; -import java.util.Map; - -public interface ImmutableMap extends Map { - - @Override - V get(final Object o); - - V getEquivalent(final Object o, final Comparator cmp); - - @Override - boolean containsKey(final Object o); - - boolean containsKeyEquivalent(final Object o, final Comparator cmp); - - @Override - boolean containsValue(final Object o); - - boolean containsValueEquivalent(final Object o, final Comparator cmp); - - ImmutableMap __put(final K key, final V val); - - ImmutableMap __putEquivalent(final K key, final V val, final Comparator cmp); - - ImmutableMap __putAll(final Map map); - - ImmutableMap __putAllEquivalent(final Map map, - final Comparator cmp); - - ImmutableMap __remove(final K key); - - ImmutableMap __removeEquivalent(final K key, final Comparator cmp); - - Iterator keyIterator(); - - Iterator valueIterator(); - - Iterator> entryIterator(); - - boolean isTransientSupported(); - - TransientMap asTransient(); - -} diff --git a/src/main/java/io/usethesource/capsule/ImmutableSet.java b/src/main/java/io/usethesource/capsule/ImmutableSet.java deleted file mode 100644 index 105e647..0000000 --- a/src/main/java/io/usethesource/capsule/ImmutableSet.java +++ /dev/null @@ -1,58 +0,0 @@ -/** - * Copyright (c) Michael Steindorfer and Contributors. - * All rights reserved. - * - * This file is licensed under the BSD 2-Clause License, which accompanies this project - * and is available under https://opensource.org/licenses/BSD-2-Clause. - */ -package io.usethesource.capsule; - -import java.util.Collection; -import java.util.Comparator; -import java.util.Iterator; -import java.util.Set; - -public interface ImmutableSet extends Set { - - @Override - boolean containsAll(final Collection c); - - boolean containsAllEquivalent(final Collection c, final Comparator cmp); - - K get(final Object o); - - K getEquivalent(final Object o, final Comparator cmp); - - @Override - boolean contains(final Object o); - - boolean containsEquivalent(final Object o, final Comparator cmp); - - ImmutableSet __insert(final K key); - - ImmutableSet __insertEquivalent(final K key, final Comparator cmp); - - ImmutableSet __insertAll(final Set set); - - ImmutableSet __insertAllEquivalent(final Set set, final Comparator cmp); - - ImmutableSet __remove(final K key); - - ImmutableSet __removeEquivalent(final K key, final Comparator cmp); - - ImmutableSet __removeAll(final Set set); - - ImmutableSet __removeAllEquivalent(final Set set, final Comparator cmp); - - ImmutableSet __retainAll(final Set set); - - ImmutableSet __retainAllEquivalent(final TransientSet transientSet, - final Comparator cmp); - - Iterator keyIterator(); - - boolean isTransientSupported(); - - TransientSet asTransient(); - -} diff --git a/src/main/java/io/usethesource/capsule/TransientMap.java b/src/main/java/io/usethesource/capsule/TransientMap.java deleted file mode 100644 index ab7c3f3..0000000 --- a/src/main/java/io/usethesource/capsule/TransientMap.java +++ /dev/null @@ -1,51 +0,0 @@ -/** - * Copyright (c) Michael Steindorfer and Contributors. - * All rights reserved. - * - * This file is licensed under the BSD 2-Clause License, which accompanies this project - * and is available under https://opensource.org/licenses/BSD-2-Clause. - */ -package io.usethesource.capsule; - -import java.util.Comparator; -import java.util.Iterator; -import java.util.Map; - -public interface TransientMap extends Map { - - @Override - V get(final Object o); - - V getEquivalent(final Object o, final Comparator cmp); - - @Override - boolean containsKey(final Object o); - - boolean containsKeyEquivalent(final Object o, final Comparator cmp); - - @Override - boolean containsValue(final Object o); - - boolean containsValueEquivalent(final Object o, final Comparator cmp); - - V __put(final K key, final V val); - - V __putEquivalent(final K key, final V val, final Comparator cmp); - - boolean __putAll(final Map map); - - boolean __putAllEquivalent(final Map map, final Comparator cmp); - - V __remove(final K key); - - V __removeEquivalent(final K key, final Comparator cmp); - - Iterator keyIterator(); - - Iterator valueIterator(); - - Iterator> entryIterator(); - - ImmutableMap freeze(); - -} diff --git a/src/main/java/io/usethesource/capsule/TransientSet.java b/src/main/java/io/usethesource/capsule/TransientSet.java deleted file mode 100644 index 2fce1f3..0000000 --- a/src/main/java/io/usethesource/capsule/TransientSet.java +++ /dev/null @@ -1,56 +0,0 @@ -/** - * Copyright (c) Michael Steindorfer and Contributors. - * All rights reserved. - * - * This file is licensed under the BSD 2-Clause License, which accompanies this project - * and is available under https://opensource.org/licenses/BSD-2-Clause. - */ -package io.usethesource.capsule; - -import java.util.Collection; -import java.util.Comparator; -import java.util.Iterator; -import java.util.Set; - -public interface TransientSet extends Set { - - @Override - boolean containsAll(final Collection c); - - boolean containsAllEquivalent(final Collection c, final Comparator cmp); - - K get(final Object o); - - K getEquivalent(final Object o, final Comparator cmp); - - @Override - boolean contains(final Object o); - - boolean containsEquivalent(final Object o, final Comparator cmp); - - boolean __insert(final K key); - - boolean __insertEquivalent(final K key, final Comparator cmp); - - boolean __insertAll(final Set set); - - boolean __insertAllEquivalent(final Set set, final Comparator cmp); - - boolean __remove(final K key); - - boolean __removeEquivalent(final K key, final Comparator cmp); - - boolean __removeAll(final Set set); - - boolean __removeAllEquivalent(final Set set, final Comparator cmp); - - boolean __retainAll(final Set set); - - boolean __retainAllEquivalent(final TransientSet transientSet, - final Comparator cmp); - - Iterator keyIterator(); - - ImmutableSet freeze(); - -}